{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notes:\n",
    " * final curated dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['/mnt/tess/astronet/checkpoints/extended_22_run_13/1/AstroCNNModel_extended_20210123_230247',\n",
       " '/mnt/tess/astronet/checkpoints/extended_22_run_13/2/AstroCNNModel_extended_20210123_233704',\n",
       " '/mnt/tess/astronet/checkpoints/extended_22_run_13/3/AstroCNNModel_extended_20210124_001135',\n",
       " '/mnt/tess/astronet/checkpoints/extended_22_run_13/4/AstroCNNModel_extended_20210124_004519',\n",
       " '/mnt/tess/astronet/checkpoints/extended_22_run_13/5/AstroCNNModel_extended_20210124_011920',\n",
       " '/mnt/tess/astronet/checkpoints/extended_22_run_13/6/AstroCNNModel_extended_20210124_015336',\n",
       " '/mnt/tess/astronet/checkpoints/extended_22_run_13/7/AstroCNNModel_extended_20210124_022808',\n",
       " '/mnt/tess/astronet/checkpoints/extended_22_run_13/8/AstroCNNModel_extended_20210124_030218',\n",
       " '/mnt/tess/astronet/checkpoints/extended_22_run_13/9/AstroCNNModel_extended_20210124_033541',\n",
       " '/mnt/tess/astronet/checkpoints/extended_22_run_13/10/AstroCNNModel_extended_20210124_040845']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "chkpt_root = '/mnt/tess/astronet/checkpoints/extended_22_run_13'\n",
    "data_files = '/mnt/tess/astronet/tfrecords-22-val/*'\n",
    "tces_file = '/mnt/tess/astronet/tces-v5-val.csv'\n",
    "\n",
    "nruns = 10\n",
    "\n",
    "def load_ensemble(chkpt_root, nruns):\n",
    "    checkpts = []\n",
    "    for i in range(nruns):\n",
    "        parent = os.path.join(chkpt_root, str(i + 1))\n",
    "        if not os.path.exists(parent):\n",
    "            break\n",
    "        all_dirs = os.listdir(parent)\n",
    "        if not all_dirs:\n",
    "            break\n",
    "        d, = all_dirs\n",
    "        checkpts.append(os.path.join(parent, d))\n",
    "    return checkpts\n",
    "\n",
    "paths = load_ensemble(chkpt_root, nruns)\n",
    "paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running model 1\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2231 records\n",
      "Running model 2\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2231 records\n",
      "Running model 3\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2231 records\n",
      "Running model 4\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2231 records\n",
      "Running model 5\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2231 records\n",
      "Running model 6\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2231 records\n",
      "Running model 7\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2231 records\n",
      "Running model 8\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2231 records\n",
      "Running model 9\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2231 records\n",
      "Running model 10\n",
      "Binary prediction threshold: 0.2152499407880693 (orientative)\n",
      "2231 records\n"
     ]
    }
   ],
   "source": [
    "import getpass\n",
    "import os\n",
    "from astronet import predict\n",
    "import tensorflow as tf\n",
    "\n",
    "\n",
    "def run_predictions(path):\n",
    "    predict.FLAGS = predict.parser.parse_args([\n",
    "      '--model_dir', path,\n",
    "      '--data_files', data_files,\n",
    "      '--output_file', '',\n",
    "    ])\n",
    "\n",
    "    return predict.predict()\n",
    "\n",
    "\n",
    "paths = load_ensemble(chkpt_root, nruns)\n",
    "ensemble_preds = []\n",
    "config = None\n",
    "for i, path in enumerate(paths):\n",
    "    print(f'Running model {i + 1}')\n",
    "    preds, config = run_predictions(path)\n",
    "    ensemble_preds.append(preds.set_index('tic_id'))\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = ['disp_E', 'disp_N', 'disp_J', 'disp_S', 'disp_B']\n",
    "\n",
    "col_e = labels.index('disp_E')\n",
    "thresh = config.hparams.prediction_threshold\n",
    "# thresh = 0.95"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "agg_preds = {}\n",
    "\n",
    "for preds in ensemble_preds:\n",
    "    for tic_id in preds.index:\n",
    "        if tic_id not in agg_preds:\n",
    "            agg_preds[tic_id] = []\n",
    "\n",
    "        row = preds[preds.index == tic_id]\n",
    "        pred_v = row.values[0]\n",
    "        if len(row.values) > 1:\n",
    "            print(f'Warning: duplicate predictions for {tic_id}')\n",
    "        if pred_v[col_e] >= thresh:\n",
    "            agg_preds[tic_id].append('disp_E')\n",
    "        else:\n",
    "            masked_v = [v if i != col_e else 0 for i, v in enumerate(pred_v)]\n",
    "            agg_preds[tic_id].append(preds.columns[np.argmax(masked_v)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_preds = []\n",
    "for tic_id in list(agg_preds.keys()):\n",
    "    counts = {l: 0 for l in labels}\n",
    "    for e in agg_preds[tic_id]:\n",
    "        counts[e] += 1\n",
    "    maxcount = max(counts.values())\n",
    "    counts.update({\n",
    "        'tic_id': tic_id,\n",
    "        'maxcount': maxcount,\n",
    "    })\n",
    "    final_preds.append(counts)\n",
    "    \n",
    "final_preds = pd.DataFrame(final_preds).set_index('tic_id')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "tce_table = pd.read_csv(tces_file, header=0).set_index('tic_id')\n",
    "tce_labels = tce_table[labels]\n",
    "\n",
    "pl = final_preds.join(tce_labels, on='tic_id', how='left', lsuffix='_p')\n",
    "\n",
    "pl.head()\n",
    "pd.set_option('display.max_columns', None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recall: 0.9741379310344828\n",
      "Precision: 0.7361563517915309\n"
     ]
    }
   ],
   "source": [
    "ppos = (pl['disp_E_p'] > 0)\n",
    "pos = (pl['disp_E'] > 0)\n",
    "\n",
    "pneg = (pl['disp_E_p'] == 0)\n",
    "neg = (pl['disp_E'] == 0)\n",
    "\n",
    "print('Recall:', len(pl[ppos & pos]) / len(pl[pos]))\n",
    "print('Precision:', len(pl[ppos & pos]) / len(pl[ppos]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "118412801\n",
      "141753278\n",
      "158159741\n",
      "349412074\n",
      "384065528\n",
      "408602527\n"
     ]
    }
   ],
   "source": [
    "for i in pl[pos & pneg][[]].join(tce_table, on='tic_id', how='left').index:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "373919592\n",
      "404851966\n",
      "14209654\n",
      "267924099\n",
      "252588526\n",
      "421845505\n",
      "192591652\n",
      "279064110\n",
      "77424138\n",
      "56861756\n",
      "159636125\n",
      "327003980\n"
     ]
    }
   ],
   "source": [
    "for i in pl[neg & ppos][[]].join(tce_table, on='tic_id', how='left').index:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>disp_E</th>\n",
       "      <th>disp_N</th>\n",
       "      <th>disp_J</th>\n",
       "      <th>disp_S</th>\n",
       "      <th>disp_B</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tic_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [disp_E, disp_N, disp_J, disp_S, disp_B]\n",
       "Index: []"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def compare(ensemble_preds, filter):\n",
    "    result = ensemble_preds[0][filter]\n",
    "    for preds in ensemble_preds[1:]:\n",
    "        result = result.append(preds[filter])\n",
    "    return result\n",
    "\n",
    "compare(ensemble_preds, preds.index == 249951802)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>disp_E_p</th>\n",
       "      <th>disp_N_p</th>\n",
       "      <th>disp_J_p</th>\n",
       "      <th>disp_S_p</th>\n",
       "      <th>disp_B_p</th>\n",
       "      <th>maxcount</th>\n",
       "      <th>disp_E</th>\n",
       "      <th>disp_N</th>\n",
       "      <th>disp_J</th>\n",
       "      <th>disp_S</th>\n",
       "      <th>disp_B</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tic_id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>421845505</th>\n",
       "      <td>10</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>10</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           disp_E_p  disp_N_p  disp_J_p  disp_S_p  disp_B_p  maxcount  disp_E  \\\n",
       "tic_id                                                                          \n",
       "421845505        10         0         0         0         0        10       0   \n",
       "\n",
       "           disp_N  disp_J  disp_S  disp_B  \n",
       "tic_id                                     \n",
       "421845505       0       1       0       0  "
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pl[pl.index == 421845505]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PR curve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "tics = set(ensemble_preds[0].index.values)\n",
    "\n",
    "tic_index = {v: i for i, v in enumerate(tics)}\n",
    "\n",
    "pred_es = np.zeros([len(ensemble_preds), len(tic_index)])\n",
    "for i, preds in enumerate(ensemble_preds):\n",
    "    for row in preds.iterrows():\n",
    "        tic, pred_e = row[0], row[1][col_e]\n",
    "        pred_es[i][tic_index[tic]] = pred_e\n",
    "\n",
    "lbl_es = np.zeros([len(tic_index)], dtype=np.bool)\n",
    "for row in tce_labels.iterrows():\n",
    "    tic, lbl_e = row[0], row[1]['disp_E']\n",
    "    if tic in tic_index:\n",
    "        lbl_es[tic_index[tic]] = (lbl_e > 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_cond_pos = float(np.sum(lbl_es))\n",
    "\n",
    "def pr_at_th(th):\n",
    "    pred_pos = np.any(pred_es >= th, axis=0)\n",
    "    true_pos = pred_pos & lbl_es\n",
    "    num_pred_pos = int(np.sum(pred_pos))\n",
    "    num_true_pos = int(np.sum(true_pos))\n",
    "    if num_pred_pos == 0:\n",
    "        return 1.0, 0.0\n",
    "    return float(num_true_pos) / float(num_pred_pos), float(num_true_pos) / float(num_cond_pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AUC: 0.9628253042405845, max R: 1.0, max P: 1.0\n",
      "100% recall at: 28%, threshold: 0.0030000000000546265\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABD0AAAKuCAYAAACi1mevAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAewgAAHsIBbtB1PgAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzdeZxbV3338e/RLs2Mx7vjfcF7bMd2EsfOShpIWUpLoAu0hbKFlm6UFAqBQkhoobSFlIfloayhhO2hUEpKCQlbQkJ2x7ETx3FsJ7bjfZ8Z7ct5/pA0I81oNnuurubez/v1knWle3Tvb65+cy395txzjLVWAAAAAAAAXhNwOwAAAAAAAAAnUPQAAAAAAACeRNEDAAAAAAB4EkUPAAAAAADgSRQ9AAAAAACAJ1H0AAAAAAAAnkTRAwAAAAAAeBJFDwAAAAAA4EkUPQAAAAAAgCdR9AAAAAAAAJ5E0QMAAAAAAHgSRQ8AAAAAAOBJFD0AAAAAAIAnUfQAAAAAAACeRNEDAAAAAAB4EkUPAAAAAADgSRQ9AAAAAACAJ1H0AAAAAAAAnkTRAwAAAAAAeBJFDwAAAAAA4Em+LXoYY6YbY37LGHOLMebHxpjjxhhbud3m0D5fb4y5yxhz2BiTMcbsNcbcbozZ5MT+AAAAAADwM2OtdTsGVxhjhvrBv2atfdMY7isu6T8lvWKQJiVJt1hrbx6rfQIAAAAA4He+7enRzz5Jdzm4/a+or+DxC0mvlrRB0lsl7Vb5ffiwMebtDsYAAAAAAICv+Lmnx82SHpH0iLX2iDFmgaTnKqvHrKeHMeY3JP2s8vAOSddZa4s166dKekzSPEmnJS2y1p4ai30DAAAAAOBnvu3pYa29yVr7P9baIw7v6t2V+4KkP68teFTiOC7pvZWHEyW9zeF4AAAAAADwBd8WPZrBGNMh6ZrKw59aa18YpOn3JXVVlq9zPDAAAAAAAHyAooezLpYUqSzfM1gja21O0oPV1xhjwk4HBgAAAACA14XcDsDjVtYs7xim7Q5J16r8niyRtH24jd98881RSaslTZd0QlJx6Ffo8HDbBAAAAABgCEFJ0yrL22666aasm8EMh6KHs+bULA92aUvV/prluRpB0UPlgscjow0KAAAAAIAxcLGkR90OYihc3uKsjprlnmHaJmuW2x2IBQAAAAAAX6Gnh7NiNcu5YdrWdgmKj3D7x6oLP0wvV7p3+BCMB8GAUShgFA5KoWBA4YBRKBhQJBRUOGgUDEghYxQKGkWCAYUCRpFwUNFQSIGAFLCl8uuCRqFAQNFwQPFoROGAUalYqDxvKm2ktnhc0VBQpWJBAVVeG5BCgYDisYgSsagCsirlcwoFpXAgoGDQKBQMKpFISJKSyaT6T3Mdj8cVDAaVzWaVz+fr1oVCIcViMRWLRaXT6bp1xhi1tbVJklKplEqlUt36WCymUCikXC6nXK7+16e63VKppFQqNeDYtrW1yRijdDqtYrH+qq9oNKpwOKx8Pq9str4nXjAYVDwel7VWyWRS/SUSCQUCAWUyGRUKhbp1kUhEkUhEhUJBmUymbl0gEBjRMWy03XA4rGg0ek7HcKj3ZrBj2N5err0OdQwbvTdjcQwbvTe1x7CnZ2ANeSTHsNF7U3sMG703IzmGjd4bqe8YNnpvhjqG55LfQx3D6nsjNT6GQ703Qx3DkeY35wjOERLniFqcI8o4R5RxjijjHNGnlc8Rhw8f1re+9a3qqmNqcab/G+NXxpgFkp6rPPyatfZNY7DNz0r688rDFdbaQcf1MMa8Q9LnKg9/11r7veG2f/PNN89R5bKYzNJrZSNtyhVLyhet8oWS8sWScsWScpXlfNH2PpcvlpQvVB4XKu2KJZEO6K9cmCkXVyKhoCJBo3AoUHkuUH5cWQ6HAooEA4qEap6rbdO7vry9vvUBhWteE6m0q+63mM/p8IEXtGjhfE1oT9Rso6+NMcbtQwWck1QqpV27dmnx4sW9H8wAryHP4QfkObyuq6tLt956a/Xh3Jtuumm4oRxcRU8PZ3XXLA93yUpbzfJwl8IM8FdXzdesWbNG+7IBiqWawkihr1CS7S2cVIoplYJJ7+OirSmuVAsttmZ9TfGl0K/4UqwvvgzaplBStvKY4kzzFEpWhVJR6bwkFYZr7rDBx+KtLaKEgwFF+xVWygWXIdr0FloaFV/6Cj21xZhwKKBo5bW9haGa/YWDRtFgsLegEwpQnMHgisWiTp06NeCvLoCXkOfwA/IcaC0UPZxVW/Gao6EHeJlbs7x/0FYOCwaMgoGgYuGgWyEMy1pbKc7YmqJIuVBS37OlNETPl/qCTL4wSIGmuo9+j3N1RSA78HGlDZqn/J4WNfwkRu5qVEQZec+X+udqH0f79Xzp3xOmvvdMo944fdsMUpwBAACAR1D0cFbtDCzLh2lbXV+Q9Kwz4XiDqYxzEQpKcbV2caZQ6TlTLcjU9o7J1hZfCjUFmpreMrU9bupfb/utb9CmQRGork3NdtE85UvJpPI/rckY1fRqaVBYCfUr0NT0lokG69vUFlrCIdPw0qQBvWPq1g8sAlXXBwMUZgAAADA0ih7OekTlAUwjkq6S9E+NGhljIpI2Vl9jrc03aofxxRjT+2WwlceYtdYO7PkyRO+Y/pc+5WqKNMP1fBnq8qh83eVNledqtl0ocU1Ts1irclGtxXsrBWqLMzU9X+oLK6amZ0z940YFmdpiTF3xpcHlUb3bGFDgMTWXS1GcgXNKpXJxvViyKpRKlXvbd18c5PlSSYVi+XHR1rYdalulftvo21axpPI2B+y7fN7ujIc1uS2sSW0RxQNFHTtR1IRjSc1RRBMT4fL/kwAAOISih4Ostd3GmJ9Jermklxhj5lhrGw3y8hpJEyrL/3U2+4pEWvhbNVqaMUaRUPnyh1aVy+V09OhRTZw8VQqG6goytWPC9B9PZvjLn/p62tQ+HtCm3+NcoTigV071McWZ5ilZKVso95pSdvj2bgkGTF1Bpn9PmGpBJmQkWzJq271d0XBoiJ4vfT1r+oov/QsyjcavGaIIFAwo4JPiTKlkla986S8U+5arv7+FynmlUKrcV57PFyuvKfVfP3jb2m2PbFvV9UO0LZaUr8Q5rk83Dz/Wu9gRC2lyW0STEpGa+3KRZHIiUr6vPD8pEdbERIRiogdYa1WyUqFUUqlUf1+sXMpceyvZvoJbw1tlfbUYWKo8V6wpxvWus+Xf3UG3acttS9Zq1exOvWrNrFGdI6PRqBYvXqxoNOrgEQQwUhQ9zoEx5k2Svlp5eLO19sMNmv2rykWPkKTPGmNeY63t7ddujJkq6eOVh6clfelsYqHoAS+LRCKaM2dO3xMt/Bmi+oWqrvjSaAalQm0vmSF6vvQryPTvLZOrKwA1KALVjFlT26Y4rr8tjS/VD9GZ/Eh7znQP38QB9TM11fd6GTBuzCCFlvpLlQbO7hQNBiSjERUKar/cl5+vL0gMVqgoVHqXebJQ4FHdmYK6MwXtPTFwasVGjKn0HqkURBoVSXqfqxRSJsTCLVPYq45NVujXI6f/4+r4ZbW9b4Z7XP59sHU9b/LDPO5fKChUiwVF27D40PC5QZ7vKzCUf/f6tx0v9hxL6l0vXTri9pFIRLNnz3YwIgCj4duihzHmckmLa56aWrO8uFLQ6GWtve1s9mOt/bkx5tuSXifptyXdbYz5N0kHJa2W9AFJ8yrN32utPXU2++k/7zPgJfl8XidPntTkyZMVDofdDmdIgYBRNBBUNNS6481IfTM1Ddo7pmYcmuF6vgxWZKntjVPbO2awabR742AabVfUz9QEtC5rpdOpvE6n8tLx5IheEzAq9xTpLYyEy8WQeFiyqru0p1B3qU9fYa72kp6+YkPf5UKDbqNYKVDUFAMwvtz55OFRFT3G0+cWwA98W/SQ9DZJfzLIussqt1q3ncO+3qLy5SuvkHR15VarJOkj1tovnO0OstkW7tsNnKNMJqMdO3Zo/fr1fHgYI+Nhpiapfhrt2mmv+w8M3Ljny8DCzsDZnQb2hOlt2+/yqMHatPrYJ4BU/tIfCpTHmAkFjILByn3A1D9fcxuwPjjI8w1fF1AoaFQqWZ1O53UqmdPJVE4nujM63p1RqskzoJesdCKZ04lkrrk7hidkCqMbfJzPLUBr8XPRo2mstWlJrzTG/KGkN0m6QNJESUck/UrSZ6y1D7gXIQC0pvFQnGk0jfZgA/fWDhTcv4DSnUzp+X37NX3mLAWCEeWKxQGFmv7TaFd71jSa3an/wMPM1DRyASOFggGFA6Z8Hyx/wQ+HjMKVL/OhQOX5YKD30qD+z4cD1dnG+rYVCvZtI1x5be0+ys/3bae83cFeXyku1BUkGhQijGmZSzu6u7u1efNmrVm7TsVgtFwMSeZ0KpXTyWS+cp/rLZL03efVk21ypQQtx5jypXgBU87xQINcDwYr95XnApVZ/2qf67sFFDQq3wfKhcFAwOhIV0YPP3fS7R8XwBjxbdHDWvsmlQsQ57KN2zSKHiDW2m9K+ua57BMA0FrGahrt7u5ubQ4e0fr189TR0TGGEZYNNo12w94xhdpLk/r3jBnYE6aud0yDabRzNWPTWGsHfNGv/8I/sBBQLiL0KygMUSgYflv1hYreQkZluVUKBF4WChhNao9qavvIB2nKFoo6naotjOT7CiO9hZPy/alkXieTOaXzrTs9+EjU9p6p5nLv42B9kStUUwSrDqA81OP6+/KX/rp7Yxo8JwWD5XW1RYfeezOw50+16NBoXW+hoiaW2m3WFSqaWLy7e/sRih6Ah/i26AEAgJ+Ml2m0gcFEQ0HNmBDUjAmxEb8mnSuWiyCpxkWSrnS+prdAoKaYMMoCQoMCRO1lQaHAII+DNQWNmsfV7RhDAa4VHOnK6I++9OCIZlnquxSzJHvnvVoxa4L+7Q/WavH0sS9mAxgZih4eEQy2btdv4FwFg0F1dHSQ5/A08hx+0Ow8j0eCikfimjUx3pT9wZsy+ZLu33XirF775IEu3fTDp/SNt20c46gAjBRFD4+Ix/nPHN6VSCS0fv16t8MAHEWeww/Ic4wHbZGxLcrdv+uENu871Xt5YL7Ud6lgoWaa+7rlylTbS2e06xWrZnLZHXAOKHoAAAAAQMW6eZM0b3JC+06mxmybr/ncr8/6tX965Rnd+IoVYxYL4DcUPTyip6dHEyZMcDsMwBHV0f7Xr1/vyACPQCsgz+EH5DnGg3gkqO+941L95KnDOpPODzvLUv/Bk+95+pA+96u9YxbPD584OGTRo1Qq9x6p9hKpDiBdOzV7dXnRtDZN7xj5uDiAF1D0AAAAAIAa0zqi+uON88/qtZMipTEtehw6k9FLP3lP7wxZuZrCRr4ymOpofOw1q/X6DfPGLD6g1VH0AAAAAIAxMrMzptcvj+jOfVanUnlFQgGFA0bhUGW67ZrlUMCU19csb9l3Wt3ZQt02nz3aM2bxfebnuyh6wFcoegAAAADAGHrZwohufM06dXR0jHrq4acPdenln/qVQ5FJB06n9Wdff6z3cpe/vHqJOhNhx/YHuI2iBwAAAACMMWPMqAsekrRsRocumj9Jj+495UBUZXc+dViS9LMd0u5jSX3lTRc7ti/AbRQ9PCKRSLgdAuCYtrY2bdiwQdFo1O1QAMeQ5/AD8hx+cK55HggYff2tl+i+Xcd1MplVOBjovQQmUrMcrgyeGq0+DlXWBwMKh/oGVt19rEcv+eS9g+7v5zuOaueRbmXzJeWKRWXzJWUrY4YsnNqmpTMYdBjjG0UPjwgEAm6HADgmEAgoHo+7HQbgKPIcfkCeww/GIs/jkaBeunLGmMSzaGq7Fk9v164hxgW59tbBiyLv+c1l+ourF49JLIAb+KbsEZlMxu0QAMek02k9/fTTSqfTbocCOIY8hx+Q5/CDVsvzQMDoW9dv1Ptevlxvu3yhrl42bVSv/9Kv9jgUGdAc9PTwiEKhMHwjYJwqFAo6evSo5syZ43YogGPIc/gBeQ4/aMU8n9YR1Z9d9SJJ0pl0XutuuUsjnen2VCqvaz7xS2ULJS2Y0qabXrVSS7jkBeMIPT0AAAAAwCc642F94JUrlYgE656PBAPqiDb+m/juY0m9cCqt+3Yd119/e0szwgTGDD09AAAAAMBH3nr5Qr1x03ylckVFKwOgBgLlmWYOnUlr08d+Puhrnz7UpVLJ9rYHWh09PQAAAADAZ8LBgDrjYcXCwboCxszO+LDjfmw/1OV0eMCYoaeHR4TDYbdDABwTiUQ0f/58RSIRt0MBHEOeww/Ic/iBF/L882+4UPc9e1zHurM6cDqtT/98V9363/7MffrDS+bp3dcu08TE+P054Q8UPTyC+e7hZdFoVAsWLHA7DMBR5Dn8gDyHH3ghz6OhoK5ZUZ4yt1As6fYH9+pUKt+7vmSl2x/cpx9tPaR/f8NF2rBwsluhAsPi8haPYPYWeFmhUNDJkyfJc3gaeQ4/IM/hB17L81AwoK+86WLNmRQfsO5UKq/3/OcTLkQFjBxFD4/IZDJuhwA4Jp1Oa9u2bS0z3z3gBPIcfkCeww+8mOfr5k3ST2+4Sje8dKli4fqvkHtPpFQollyKDBgeRQ8AAAAAwJBi4aD++pol+sbbNg5Y9/3HD6hUsi5EBQyPMT0AAAAAACMyvWPgWIJ/959b9fUH9urPX/wihYIBpXIFZfJFzZ2c0MaFU5jeFq6i6AEAAAAAGJE5k+JaNK1Ne44l657fduCM3vGNzQPav/myBbrpVec3KzxgAIoeHhEIcKUSvCsQCCgWi5Hn8DTyHH5AnsMPvJ7nxhjd/tZLdOP3t+menceGbf/V+5/XWy5bqGyhqFSufEtX7udMimvNnE4ZQ08QOIeih0ckEgm3QwAc09bWpksuucTtMABHkefwA/IcfuCHPJ81Ma6vvWWDfvHMUf3D/2zX7n69Pvq74p9/Mei6t1+5SO9/xYoxjc9aq0y+pGSu0FtgSeYKmtkZ08zOgbPQwNsoegAAAAAARu3qZdN1+eKp+uZD+/Tdx/br8JmMjvfkRrWNL9y7R2/cNF/5olUyW1A6Xyzf56o9QwqVokVR6Vyhcl/sbZuqWU5my21S+aLsIOOq/vVvLNYN1y4bg58e4wVFD49IJpOaMGGC22EAjujp6dHWrVu1Zs0atbe3ux0O4AjyHH5AnsMP/Jbn4WBAf3LpAv3JpQskSclsQWtvuUv54shnc7n844P3BBlrn79nj97x4sWKR4JN2yfc5c0LzXzIDlbKBDzAWqt8Pk+ew9PIc/gBeQ4/8Huet0VD+puXLFWjYToiQfe/fuaKJR08k3Y7DDQRPT0AAAAAAGPmL65erDdumq9j3VklIiElokElwkGFggGlc0VdcMtdyhVKrsV3zSfu0U2vWqnXb5inWJgeH15H0QMAAAAAMKY6YmF1xMIDno9HgnrXS5bqn3+yY8C4G6GAUTwSVFskpEQkWCmWVIomkWC5gBIJ1rfpvQ/2FVgifa+LhgK69GM/V3e2ULevm+/Yri/cu0effv06XbRgspOHAi6j6AEAAAAAaJp3vPhF+sNL5ulYd6amaBFSJOTM5S9/e+1SffiO7QOeP3Qmo7d//TE98oGXKBhg2lyvoujhEfE4Uy/BuxKJhNauXcvUzPA08hx+QJ7DD8jzkemMh9UZH9gTxAlvumyh1s+fpE/evVO/fOZY3bqTyZwu+ehP1RkPa8aEmN79m8u0ft6kpsSF5nB/JBmMiWCQa9HgXcFgUJ2dneQ5PI08hx+Q5/AD8rw1rZkzUbe9eYO+9pYNA9Yd78lp97Gkfr37hK7/2qMqlvw5CK1XUfTwiGw263YIgGOy2ax27dpFnsPTyHP4AXkOPyDPW9vGRZMVGuJSlhPJnA6eZnYXL6Ho4RH5fN7tEADH5HI5HThwQLlczu1QAMeQ5/AD8hx+QJ63tmgoqJevnul2GGgixvQAAAAAAPjGJ37vAl2zfLpeOJVSOBjQx368w+2Q4CCKHgAAAAAA34iEAnr1utmSpHSuSNHD4yh6AAAAAABQ8c2H9ykcMJo2IaZXr52ljlhzZpmBMyh6eEQoxFsJ7wqHw5o1a5bCYf7DgXeR5/AD8hx+QJ6Pf//3l7t7l3+45YC++2eXuhgNzhXflD0iFou5HQLgmFgspiVLlrgdBuAo8hx+QJ7DD8jz8cUMPpGLJOmR50/paFdG0yfwfWu8YvYWjygWi26HADimWCyqu7ubPIenkefwA/IcfkCejy+xcFBLZ7QP2Sad570czyh6eEQ6zVzS8K5UKqXNmzcrlUq5HQrgGPIcfkCeww/I8/Hnc390oa5eNk1LZ7TrgrkT3Q4HY4zLWwAAAAAAvrV4eru++uYNkqRMvqjlH7zT5YgwlujpAQAAAAAAPImiBwAAAAAA8CQub/EIM9yww8A4ZoxRMBgkz+Fp5Dn8gDyHH5Dn3rN53yntONytqe1RrZ07UcEA7+14QtHDI9ra2twOAXBMe3u7Lr/8crfDABxFnsMPyHP4AXnuPe/6zhO9y69dP0ef+P0LXIwGo8XlLQAAAAAAjMD3Nr+gk8mc22FgFCh6eARTYsHLksmkHnnkESWTSbdDARxDnsMPyHP4AXk+vkVDAZ03ITZkmzPpfJOiwVig6OERpVLJ7RAAx5RKJaVSKfIcnkaeww/Ic/gBeT6+GWP0kVev0qREWJLE8B3jH2N6AAAAAABQ8dKVM7T5gy9VKldUKGi07O/vdDsknAOKHgAAAAAA1DDGqC0aUq4wsMfOj7YeVCQU0NT2qF626jwlInytbmW8OwAAAAAAjNC/3rWzd/m7j76gb71944A2pZJVd7agM6m8zqTzOp3OaXJbRCvOm6AA18w0FUUPj4jFhh5sBxjP4vG4zj//fMXjcbdDARxDnsMPyHP4AXnuLw/sOaHf//wDioYDOpOuFDhSeXVn8irZge1fs362Pvn7a5sfqI9R9PCIUIi3Et4VCoU0depUt8MAHEWeww/Ic/gBee4tkVBAi6a2ac/xwWfjefj5kyPe3vc3H9D7XrZc04eZIQZjh9lbPCKXY65oeFcul9O+ffvIc3gaeQ4/IM/hB+S593zyD9Zq1ewJmpgIa+7kc+/BcyJJbjQT3QM8gpMqvCybzeq5557TpEmTFIlE3A4HcAR5Dj8gz+EH5Ln3rJ07Uf/zV1f0Pn7Dlx/Sr5497mJEGA2KHgAAAAAAjNBnXr9en793t/afTKkzHlZnPKyJiXBlOTLguVUf/olsg/E90BwUPQAAAAAAGKHORFjvfdnyEbc3kmprHv985w5J0qS2iP70yhdp2XkdYxsg6lD0AAAAAACgSX7xzLHe5Xt3HtODN16jUJDhNp3CkfUIZm+Bl1VHQSfP4WXkOfyAPIcfkOfoLxQY/Gv38Z6cdh8bfGYYnDuKHh4RizHlEbyL+e7hB+Q5/IA8hx+Q5+hv04umDLm+UCo1KRJ/oujhESV+UeBhpVJJ2WyWPIenkefwA/IcfkCeo7//87p1uv6Khbp25Qz93oVzZIzbEfkLRQ+PSKVSbocAOCaZTOrBBx9UMknXP3gXeQ4/IM/hB+Q5+utMhPWBV67UF954kf7l9y5QKEDVo5koegAAAAAAAE9idB0AAAAAAFxy11NHdP+u45oYj+jlq89TRyzsdkieQtEDAAAAAACXfOpnz/Yuf+OhvfrBX1wmw8AfY4bLWwAAAAAAaAFPvHBGzx1nPJixRE8Pj2hra3M7BMAx7e3tuuKKK6h4w9PIc/gBeQ4/IM8xnMXTO/T0oa5B16dyxSZG43309PAITqrwMmOMAoEAeQ5PI8/hB+Q5/IA8x3A+/trVWn5ehxKRoGZ1xtwOx/MoenhEOp12OwTAMalUSlu2bGFqZngaeQ4/IM/hB+Q5hrNmzkTd+TdXavstL9Ovb7xGkRBfy53E0fWIYpEuUPCuYrGoM2fOkOfwNPIcfkCeww/Ic6C1UPQAAAAAAACeRNEDAAAAAAB4EkUPAAAAAADgSRQ9PCIajbodAuCYWCympUuXKhZjdGt4F3kOPyDP4QfkOdBaQm4HgLERDofdDgFwTDgc1syZM90OA3AUeQ4/IM/hB+Q50Fro6eER+Xze7RAAx+TzeR06dIg8h6eR5/AD8hx+QJ4DrYWih0dks1m3QwAck8lktHPnTmUyGbdDARxDnsMPyHP4AXkOtBaKHgAAAAAAwJMoegAAAAAAAE+i6AEAAAAAADyJoodHBINBt0MAHBMMBtXZ2Umew9PIc/gBeQ4/IM+B1sKUtR4Rj8fdDgFwTCKR0Nq1a90OA3AUeQ4/IM/hB+Q50Fro6eER1lq3QwAcY61VqVQiz+Fp5Dn8gDyHH5DnQGuh6OERyWTS7RAAx/T09OhXv/qVenp63A4FcAx5Dj8gz+EH5DnQWih6AAAAAAAAT6LoAQAAAAAAPImiBwAAAAAA8CSKHgAAAAAAwJMoekgyxsw3xnzCGLPDGJM0xpw0xjxijHmPMSYxRvtYYIz5uDHmMWPMaWNMvrKfXxtjPmSMmX4u208kxiRMoCW1tbVp48aNamtrczsUwDHkOfyAPIcfkOdAawm5HYDbjDGvknS7pAk1TyckXVS5vc0Y80pr7a5z2McbJP27pHi/VZMkbarc3mmMeZ219u6z2UcgQP0K3hUIBBSNRt0OA3AUeQ4/IM/hB+Q50Fp8/U3ZGLNO0ndULnj0SPqApEslXSPpi5VmSyX9yBjTcZb7uEzSbSoXPEqSvirp1ZI2SPpdSXdUmk6W9N/GmEVns59MJnM2LwPGhXQ6raeeekrpdNrtUADHkOfwA/IcfkCeA63F10UPSZ9SuRhRkHSttfaj1toHrLU/t9a+XdLfVdotlfS3Z7mPG9V3nP/KWvsWa+1/W2sfsdZ+z1r725I+WVkfl3TD2eykUCicZXhA6ysUCjp+/Dh5Dk8jz+EH5Dn8gDwHWotvix7GmA2Srqg8/LK19oEGzT4h6enK8juNMeGz2NWllfsT1trPDdLmlprlTWexDwAAAAAA0I9vix4qX2JS9dVGDay1JUn/UXk4UdLVZ7GfSOX+ucEaWGvPSDrerz0AAAAAADgHfi56XF65T0p6bIh299QsX3YW+3mmcr9wsAbGmAmSpvZrDwAAAAAAzoGfZ29ZUWzGS0cAACAASURBVLnfZa0d6oK7HQ1eMxqfl/QFSVOMMX9mrf18gzYf7Nd+1HK5nLq6uoZsM2HChCHXA60qGo1q4cKFjIQOTyPP4QfkOfyAPAdaiy+LHsaYmPp6VrwwVFtr7SljTFJSm6S5Z7G7r6jcq+SNkj5rjLlQ0g8lHZI0T9Ib1HepzT9aa396FvvQ1772tWHb3HBD3xipHR3lyWhSqZSKxWJdu1gspnA4rFwup2w2W7cuGAwqkUjIWquenp4B+2hra1MgEFA6nR4weFM0GlUkElE+nx8w20wgEOidy7y7u3vAdhOJhILBoDKZjPL5fN26SCSiaDSqQqEwYJRsY4za29slST09PbLW1q2Px+MKhULKZrPK5XJ168LhsGKxmIrFolKp1ICYqscwmUyqVCrVrRvqGIZCIcXjcZVKJSWTyQHbbW9vlzGm4Xsz1DGsvjdS42M41Hsz1DGsfW8aHcPqezPaY1j73jQ6htX3pnoMJ02apGw2q2w2e07HsPreDHUMzyW/z+UYDpXf53IMG703wx1DzhFlzT5HTJo0qfd4c44Y3TmiFueIslY9R8ybN0/W2lHnIeeIMj5HlLXyOSIcDtd9bhnJMeQcUebXzxHq97ryMe3sXW61c0Sj96aV+bLoIal2+tmRvGPVokf7aHdkrS1K+hNjzB2S3i/pbZVbrV9I+ujZFjxGavPmzb3LV111lSRpx44dA37xly9frhkzZujYsWPatWtX3bpJkyZpzZo1KhaLddur2rRpkyKRiHbv3q0TJ07UrVu0aJHmzp2r06dPa/v27XXr2tvbdeGFF0qSHn/88QEnjIsuukhtbW3au3evDh8+XLdu7ty5WrRokXp6evTEE0/UrYtEItq0qTw27LZt2wacbC644AJNnDhRBw4c0P79++vWnXfeeVq2bJkymcyAn9UYoyuvvFJS+Rj2/8VfuXKlpk2bpiNHjmjPnj1166ZMmaJVq1apUCg0PIaXXXaZQqGQdu3apVOnTtWtW7x4sWbPnq2TJ09qx44ddes6Ojq0fv16SWq43Q0bNigej+v555/X0aNH69bNnz9fCxYsUFdXl7Zt21a3LhaL6ZJLLpEkbd26dcB/BGvXrlVnZ6f279+vAwcO1K2bNWuWlixZolQqNSCmYDCoyy8vX2W2ffv2Af8Rn3/++Zo6daoOHz6s556rHxJn6tSpOv/885XP5xv+rFdccYWMMdq5c6fOnDlTt27p0qWaOXOmjh8/rp07d9at6+zs1Nq1a2WtbbjdjRs3KhqNas+ePTp+/HjduoULF2revHk6ffq0nnrqqbp1iURCF198sSRpy5YtA/6DWb9+vTo6OrR//34dPHiwbt3s2bO1ePFi9fT0aMuWLXXrwuGwLr20PFbyk08+OeA/p9WrV2vy5Mk6dOiQ9u7dW7du+vTpWrFihbLZbMOflXNEmRvniOox5BzBOaLKS+eIiRMnavbs2Wpvb+ccwecISd48Rwy2Xc4RZXyOKKs9R/SP55lnntElS2dJas1zRP/f81Zn+h9gPzDGzJW0r/Lw69baNw7Tfp/KvTx2W2sXn8X+Vkj6uKSXq3GhKSPpB5Leba090GB9QzfffPMcSfsl6brrrtPUqVN714VCIcViMZVKpd7/BKoV19plqq/8hUZq/b/QnDp1Sjt27NDy5cuVSCT4K+4ojyF/oRkf54hUKqUdO3b0flDnHNG6f8XlHHH254hMJqPt27dr3bp1MsYM2C7niDI+R5SN13NEV1eXHn/88d7PLSM5hpwjyvz6OWLFh36iXLHvtd95y7reokcrniMOHjyoL37xi9VVc2+66aYhr55wm1+LHtMkVUvU37HWvm6Y9kckTZf0pLV29Sj3dYWkO1Tun7RX0t9LulvSSUkzJP22pI9ImizpoKRrrbVPNd5avdqix/XXX69Zs2aNJjRg3Oju7tbmzZt7/5IBeBF5Dj8gz+EH5DlGa+nf/1i5Ql9h43/+6nKtmt3pYkRD6+rq0q233lp92PJFD79e3lJb3hvJJSttlftRXbxkjIlK+pbKBY/DkjZaa2v7S70g6XPGmHskPSpplqSvSbpoNPsBAAAAAAAD+XLKWmttRlL1IrA5Q7U1xkxSX9Fj/1BtG3iZpNmV5U/3K3jUxvOUpNsrDy80xlwwyv0AAAAAAIB+fFn0qKiObrPYGDNUj5flNctPj3IftVPcDhxFpt5jg+xzRAIBP7+V8LpAIKBEIkGew9PIc/gBeQ4/IM+B1uLXy1sk6T5JV6jci+NCSQ8N0u6qmuX7R7mP2tF1hjvW4UFeNyK1gyQBXtPW1tY7ajngVeQ5/IA8hx+Q50Br8XP58Qc1y29u1MAYE5BUndnltMpTy45G7fxYVwzTtra48tygrQAAAAAAwIj4tuhhrX1Y0q8qD99qjNnUoNnfqu8SlU9Za+vmLzLGvNgYYyu32xq8/meSqnNDvcMY03DmF2PMyyVdV3l4QNKWRu2G0mg6IsArenp6dN999zWcugzwCvIcfkCeww/Ic5yrbzy0Tzd+f5s+9uOn9cKpgVNeY3T8fHmLJL1T5UtW4pLuMsZ8VOXeHHFJr5P09kq7nZI+MdqNW2tPG2P+SdItkjok/doY82mVp6w9pfKUtb8j6Xr1FaDeZ60tNdreMPsa7UuAccNaq2KxSJ7D08hz+AF5Dj8gz3GuvvXwvt7l/3nikO79u6sVDBgXIxrffF30sNY+boz5A5VnTpkg6aMNmu2U9EprbXeDdSPxD5Imq1xgaZd0Y+XWX17S+621tzdYBwAAAADwmQOn09p5pFsrZk5wO5Rxy7eXt1RZa++QtEbSrSoXOFIqj9/xqKT3Slpnrd11Dtu31tp3SbpY0uclPSmpW1JR0hmVZ235pKRV1tp/PYcfBQAAAAAwzqw4r2PI9bnCqC8EQA1f9/SostbulXRD5Taa1/1S0oj6GVlrH1P9tLQAAAAAAJ/7+O+u0fu+t00vnEprWkdUOw53iaujxg5FD4+Ix+NuhwA4JpFIaP369UzNDE8jz+EH5Dn8gDzHaC0/b4J+8BeX9T3+4I+Vydf37rDW6lQqr4On0zp8JqNDXRl1REN6ycoZao/ytX4oHB2PCAaDbocAOCYYDKqjY+huf8B4R57DD8hz+AF5jrF2/X88qtPpfMPLXNbM6dR//8VlMoaBTgfj+zE9vCKTybgdAuCYTCajZ599ljyHp5Hn8APyHH5AnmOsHe3ODjqux9YXzujZo0yPPBSKHh5RKBTcDgFwTD6f18GDB5XP590OBXAMeQ4/IM/hB+Q5zlU0NLpe/N0ZvgsOhaIHAAAAAAAt4tqVMwZdx1Uso8eYHgAAAAAAtIh/vG611szp1P5TaU3viOq8zphmdsZ0Xmdc0zuiWnfL3erJ0rtjpCh6AAAAAADQIiKhgN6waYHbYXgGRQ+PCIfDbocAOCYSiWj27NmKRCJuhwI4hjyHH5Dn8APyHM12xxMH9ZOnDisRCeoPLp6rmZ1xt0NqKRQ9PCIajbodAuCYaDSqxYsXux0G4CjyHH5AnsMPyHM0222/fr53+buPvqB73vNihYIM31nFkfCIYrHodgiAY4rFos6cOUOew9PIc/gBeQ4/IM/hpgOn03r6ULfbYbQUih4ekU6n3Q4BcEwqldKWLVuUSqXcDgVwDHkOPyDP4QfkOZz2ountQ67PFii41aLoAQAAAADAOPGR3zlfi6e3KxIKaPbEuAJMYzskxvQAAAAAAGCcWDNnon56w1Wy1soYozUf/om6MkxhOxh6egAAAAAAMM4YQxePkaDo4REkPLzMGKNwOEyew9PIc/gBeQ4/IM+B1sLlLR7R1tbmdgiAY9rb23XppZe6HQbgKPIcfkCeww/Ic7jt+48f0B1PHFQiGtLrL56neVMSbofkKooeAAAAAAB4xDcf2te7/L3HXtB97/0NRUL+vcjDvz+5xzAlFrwsmUzqoYceUjKZdDsUwDHkOfyAPIcfkOdoJUe7s9p+qMvtMFxF0cMjSqWS2yEAjimVSspkMuQ5PI08hx+Q5/AD8hzNtmRGx5DrcwV/5yJFDwAAAAAAxqmP/M4qLT+vQ22RoBZMSSjAGLp1GNMDAAAAAIBxauWsCbrzb67sfbz2lrt0OpV3MaLWQk8PAAAAAADgSRQ9PCIWi7kdAuCYeDyu1atXKx6Pux0K4BjyHH5AnsMPyHOgtXB5i0eEQryV8K5QKKTJkye7HQbgKPIcfkCeww/Ic6C10NPDI7LZrNshAI7JZrN6/vnnyXN4GnkOPyDP4QfkOdBaKHp4RD7PQDXwrlwup7179yqXy7kdCuAY8hx+QJ7DD8hzoLVQ9AAAAAAAAJ5E0QMAAAAAAHgSRQ8AAAAAAOBJFD08gtlb4GWhUEjTp08nz+Fp5Dn8gDyHH5DnQGvhN9EjYrGY2yEAjonH41qxYoXbYQCOIs/hB+Q5/IA8B1oLPT08olQquR0C4JhSqaR0Ok2ew9PIc/gBeQ4/IM+B1kLRwyNSqZTbIQCOSSaTevjhh5VMJt0OBXAMeQ4/IM/hB+Q50Fq4vAUAAAAAAI+67dfP6av3P6d4OKi3XL5Qq2Z3uh1SU1H0AAAAAADAo/532+He5bu2H9EjH3iJ4pGgixE1F5e3AAAAAADgAz3Zgp48eMbtMJqKogcAAAAAAB6xcuaEIdcXirZJkbQGih4e0d7e7nYIgGM6Ojp01VVXqaOjw+1QAMeQ5/AD8hx+QJ7DbR+9brU2LpqsWZ0xrZ07UeGgcTskVzGmBwAAAAAAHrFgapu+/fZNvY/Xf+RunUzmXIzIXfT08Ih0Ou12CIBjUqmUNm/ezNTM8DTyHH5AnsMPyHOgtVD08Ihiseh2CIBjisWiuru7yXN4GnkOPyDP4QfkOdBaKHoAAAAAAABPougBAAAAAAA8iaIHAAAAAADwJIoeHhGNRt0OAXBMLBbT8uXLFYvF3A4FcAx5Dj8gz+EH5DnQWpiy1iPC4bDbIQCOCYfDmjFjhtthAI4iz+EH5Dn8gDwHWgs9PTwil/PvvMvwvlwupwMHDpDn8DTyHH5AnsMPyHOgtVD08AhOqvCybDarXbt2KZvNuh0K4BjyHH5AnsMPyHOgtVD0AAAAAAAAnkTRAwAAAAAAeBJFDwAAAAAA4EkUPTwiGAy6HQLgmGAwqEmTJpHn8DTyHH5AnsMPyHOgtTBlrUfE43G3QwAck0gktGbNGrfDABxFnsMPyHP4AXkOtBZ6eniEtdbtEADHWGtVKBTIc3gaeQ4/IM/hB+Q50FooenhEMpl0OwTAMT09Pbr//vvV09PjdiiAY8hz+AF5Dj8gz4HWQtEDAAAAAAB4EkUPAAAAAADgSRQ9AAAAAACAJ1H0AAAAAAAAnsSUtR6RSCTcDgFwTFtbmzZt2qRQiFMWvIs8hx+Q5/AD8hxoLfwmekQgQKcdeFcgEFAkEnE7DMBR5Dn8gDyHH5DnQGvhm7JHZDIZt0MAHJNOp/Xkk08qnU67HQrgGPIcfkCeww/Ic6C1UPTwiEKh4HYIgGMKhYJOnDhBnsPTyHP4AXkOPyDPgdZC0QMAAAAAAHgSRQ8AAAAAAOBJFD0AAAAAAIAnUfTwCEaIhpdFo1EtWrRI0WjU7VAAx5Dn8APyHH5AngOthSlrPYKiB7wsEolo7ty5bocBOIo8hx+Q5/AD8hxoLfT08Ih8Pu92CIBj8vm8jh07Rp7D08hz+AF5Dj8gz4HWQtHDI7LZrNshAI7JZDLavn27MpmM26EAjiHP4QfkOfyAPAdaC0UPAAAAAADgSRQ9AAAAAACAJ1H0AAAAAAAAnkTRwyMCAd5KeFcgEFB7ezt5Dk8jz+EH5Dn8gDwHWgtT1npEIpFwOwTAMW1tbbrwwgvdDgNwFHkOPyDP4QfkOdBaKHoAAAAAAOAT33x4n25/aK9ioaDefNkCrZrd6XZIjqLPlUf09PS4HQLgmO7ubt17773q7u52OxTAMeQ5/IA8hx+Q52h1dzxxUD/aekjf2/yCXveFB5XKFdwOyVEUPQCMC9Zat0MAHEeeww/Ic/gBeY7xoidb0LYXzrgdhqMoegAAAAAA4FFLprcPub5Y8naRjqIHAAAAAAAe9eHfPl8rZk5QezSkJdPbFQoYt0NqKgYyBQAAAADAo1bMnKAfv/OK3scX/cPdOt6TczGi5qLo4RHxeNztEADHJBIJXXTRRYrFYm6HAjiGPIcfkOfwA/IcaC0UPTwiGAy6HQLgmGAwqLa2NrfDABxFnsMPyHP4AXkOtBbG9PCITCbjdgiAYzKZjJ555hnyHJ5GnsMPyHP4AXkOtBaKHh5RKHh7bmX4Wz6f1+HDh5XP590OBXAMeQ4/IM/hB+Q50Fq4vAUAAAAAAJ/6wA+e1NzJCS2YktAbN83X4ukdboc0pih6AAAAAADgU88dT+q540ndK+lHWw/p3r+7Wm1R75QKuLwFAAAAAACfmDFh8JmFTiRzevLAmSZG4zyKHh4RDofdDgFwTCQS0dy5cxWJRNwOBXAMeQ4/IM/hB+Q5Wt17fnOZ2ofoyZEv2iZG4zxX+qwYY6ZIeoOkKyUtlNSh4Qsw1lr7IofimS/pryW9UtJcSVlJuyX9P0mftdamxnBfL5H0x5IulzRTUkHSEUlbJf1M0tettT2j3W40Gh2rEIGWE41GtWjRIrfDABxFnsMPyHP4AXmOVvfiZdP16N+/RLuO9uhYT1Z//a3H1Z3x7sQYTS96GGNeI+nLkiZUnxrhSx0pNxljXiXp9pp4JCkh6aLK7W3GmFdaa3ed434mSfqqpN9psHqCpCWSXivpAUlbRrt9Zm+BlxUKBfX09Ki9vV2hkHeuLwRqkefwA/IcfkCeYzyIhYNaNbuzd9nLRY+mXt5ijLlI0rcldapc7KgWPOwwN6fiWSfpOyoXHXokfUDSpZKukfTFSrOlkn5kjDnrIWyNMZ2S7lZfweO/JP2RpI2SLpb0GkmfkvTC2e6DecDhZel0Wk888YTS6bTboQCOIc/hB+Q5/IA8B1pLs0uP76vss1UuEvqUpLjKl5hca619oGbdz40xz0r6Z5ULH38r6cNnuZ9PS7pQ5ctmft9a+8N+6x+V9F/GmHdJCp7lPgAAAAAAQI1mD2R6ueoLHmaEtzFnjNkg6YrKwy/3K3hUfULS05XldxpjRj1aqDHmcpXHL5Gkv29Q8Ohly7zbrwgAAAAAgCZqdtFjYuW+Wsj4hMpjWbRLCllrA0PcxroHxKtrlr/aqIG1tiTpP2piv/os9vOXlfszkj5zFq8HAAAAAABnodlFj6OVeyvpbmvte6y1u621qUqBoZkur9wnJT02RLt7apYvG80OjDER9Y3jcbe1NlN5PmiMmWuMWWCMGXyS5NHtayw2A7QkY4wikQh5Dk8jz+EH5Dn8gDwHWkuzix73qK+Xx54m77u/FZX7XcNcUrKjwWtG6gJJ1aLGNmPMBGPMv0k6LmmfpOcknTHG3G2MefEot12nra3tXF4OtLT29nZt2rRJ7e3tbocCOIY8hx+Q5/AD8hxoLc0eyPTTkl6vcuHjKmOMsdY2fVDTSu+KqZWHQ86YYq09ZYxJSmqTNHeUu1pZsxxQecDSJf3aRCS9RNI1xpgbrbUfH+U+JEnd3d3DtpkwYcKwbQAAAAAA8IqmFj2stQ8bY/5J0vslLZf0FWPMu621J5oZh6Ta6Wd7RtC+WvQYbbl2cs3ye1Xu9XGnpA9J2qryVLmvlfRPKk/j+0/GmB3W2v8e5X70pS99adg2N9xwQ+9yR0f5EKRSKRWLxbp2sVhM4XBYuVxO2Wy2bl0wGFQikZC1Vj09Aw9dW1ubAoGA0um0CoX6DjTRaFSRSET5fH7AFLuBQKC3t0qjAk4ikVAwGFQmk1E+n69bF4lEFI1GVSgUBkwNZozprbL39PSof40tHo8rFAopm80ql8vVrQuHw4rFYioWi0qlUgNiqh7DZDKpUqn+6qyhjmEoFFI8HlepVFIymRyw3fb2dhljGr43Qx3D6nsjNT6GQ703Qx3D2vem0TGsvjejPYa1702jY1h9b3K5nE6fPq1nn31WS5Ys6X3+bI9h9b0Z6hieS36fyzEcKr/P5Rg2em+GO4acI8qaeY5Ip9N69tlntXz5ck2ZMoVzxCjOEWN5nuUcUebUOSKbzerZZ5/VqlWrBmxT4hxRxeeIsvF6juju7tbWrVt7P7eM5Bhyjijjc0SfZp4jbKk+7kKxMOA41Z4jGr03raypRQ9jzIck5VQe22O6pDdK+n1jzN2S9koasvhhrb1ljEKpHUcjN2irPtVMig/ZaqDaa05iku6W9FvW2upv/jFJnzfGPKnypT8BSR8zxvzQiR4wmzdv7l2+6qqrJEk7duwYkNDLly/XjBkzdOzYMe3atatu3aRJk7RmzRoVi8W67VVt2rRJkUhEu3fv1okT9W/nokWLNHfuXJ0+fVrbt2+vW9fe3q4LL7xQkvT4448POGFcdNFFamtr0969e3X48OG6dXPnztWiRYvU09OjJ554om5dJBLRpk2bJEnbtm0bcLK54IILNHHiRB04cED79++vW3feeedp2bJlymQyA35WY4yuvPJKSeVj2P8Xf+XKlZo2bZqOHDmiPXvqr+SaMmWKVq1apUKh0PAYXnbZZQqFQtq1a5dOnTpVt27x4sWaPXu2Tp48qR07dtSt6+jo0Pr16yWp4XY3bNigeDyu559/XkePHq1bN3/+fC1YsEBdXV3atm1b3bpYLKZLLrlEkrR169YB/xGsXbtWnZ2d2r9/vw4cOFC3btasWVqyZIlSqdSAmILBoC6/vDy0zvbt2wec7M8//3xNnTpVhw8f1nPPPSdJevrp8mRKU6dO1fnnn698Pt/wZ73iiitkjNHOnTt15syZunVLly7VzJkzdfz4ce3cubNuXWdnp9auXStrbcPtbty4UdFoVHv27NHx48fr1i1cuFDz5s3T6dOn9dRTT9WtSyQSuvjiiyVJW7ZsGfCf//r169XR0aH9+/fr4MGDdetmz56txYsXq6enR1u2bKlbFw6Hdemll0qSnnzyyQH/wa9evVqTJ0/WoUOHtHfv3rp106dP14oVK5TNZhv+rJwjytw4R+zfv19TpkzhHHEW54gqzhFlrXiO6OjoUC6XU7FYHPD7KHGOqOJzRNl4PUeUSiUVCoXezy1VnCPK+BxR1krniHyh/veyu6tbm488U/dc7Tmi/+95qzPNvLrEGFPSwClr1e+5QY3VDC7GmGnqG1T1O9ba1w3T/ojKRZonrbWrR7Gfd0v6l5qn1ltrHx+k7Xcl/W7l4QXW2q3Dbf/mm2+eI2m/JF133XWaOnVq77pQKKRYLKZSqdT7n0C1Wli7TPV1fFRfq/z6F5pTp05px44dWr58uRKJBH/FHeUx5C804+MckUqltGPHjt4P6pwjWvevuJwjzv4ckclktH37dq1bt67hII+cI8r4HFE2Xs8RXV1devzxx3s/t4zkGHKOKONzRJ9mniOu/rcHdTzZF99tb7pQF86uHzOy9hxx8OBBffGLX6yumnvTTTcNOWSE29wqevQvdoxkaGM7hkWPmKRqxv7IWvtbw7TvUbnXxoPW2k2j2M+fSvp85eExa+30Idq+TVI1c95mrf3ycNuvLXpcf/31mjVr1khDA8aV7u5ubd68ufcvGYAXkefwA/IcfkCeY7y5+B9/qmPdfcWT2996iS5fMnXQ9l1dXbr11lurD1u+6NHs2VuqrOp7d9hhbmO78/LUsdX+UHOGamuMmaS+y1T2D9W2gdr2wyVCbdtpo9wPAAAAAADox42ihzmLmxOqF3otNsYMNbbJ8prlpwdt1VjtBXnD9VKpXT/UFLoNxWKx4RsB41Q8HtcFF1xQNxgY4DXkOfyAPIcfkOdAa2n2lLVvbvL+hnKfpCtU7sVxoaSHBml3Vc3y/aPZgbV2rzFmn6R5khYMM0Xvi2qWDwzSZlChULPfSqB5QqGQJk6c6HYYgKPIc/gBeQ4/IM+B1tLsKWu/1sz9DeMHkm6sLL9ZDYoexpiAyjPMSNJpSb84i/18T9K7VJ6e9hpJPx2k3Wtqlu8b7U76D2ADeEk2m9WBAwc0e/ZsRaNRt8MBHEGeww/Ic/gBeQ60FrfG9HCdtfZhSb+qPHyrMabRAKV/K2lFZflT1tq6oXyNMS82xtjK7bZBdvVvkqrDB3/SGDOhfwNjzB9LenHl4Y+staMdO2TAKMOAl+RyOe3fv3/AqNeAl5Dn8APyHH5AngOtpWWKHsaY0DBjazjhnSrP4hKSdJcx5kZjzEZjzNXGmH+X9M+VdjslfeJsdmCt3SfpQ5WHqyU9bIx5szHmwsp+Pi3ptsr6LpV7hQAAAAAAgHPk2kAQxpiIpLdIerWkiyVNrDx/WtIjkv5L0lettY6VSK21jxtj/kDS7SpffvLRBs12SnqltXbghM4j38+/GGMmS3qvpGWSvtKg2VFJr7bWPnu2+wEAAAAAAH1c6elhjFkv6RlJn5X0UkmT1DdTy6TKc5+TtMMYs87JWKy1d0haI+lWlQscKZXH73hU5SLFOmvtrjHYz42SLpP0dUnPS8pKOqNygeeDkpZaax841/0AAAAAAICypvf0MMaskXSvpLj6pqPtP6NJ9fkFku41xmyy1j7pVEzW2r2SbqjcRvO6X2oUU+pWihqOFDaYvQVeFg6Hdd555ykcDrsdCuAY8hx+QJ7DD8hzoLU09ZtyZTaUb0tKqFzoGGz61trn2yR92xizeojpXn0vFou5HQLgmFgspmXLlrkdBuAo8hx+QJ7DD8hzoLU0+/KW10harvqihhnkVmuFpNc2I8Dxqlgsuh0C4JhisahkMkmew9PIc/gBeQ4/IM+B1tLsosera5aNpOOS/kbSEkmxym1J5bnjQ7wW/aTTabdDAByTSqX06KOPKpVKuR0K4BjyHH5AnsMPyHOgtTR7IIgNKvfyMJKSki611u7u12a3pP9jjPmxpMfVN/bHhmYGCgAAAAAAgL65ywAAIABJREFUxrdm9/SYXrm3kv63QcGjV2Xq1h+p71KX6YO1BQAAAAAA6K/ZRY94zXL/y1caOVGzzEidAAAAAABgxJpd9DhVuR/p5Sq1bU6PfTgAxgtjRjw7NDBukefwA/IcfkCeA62j2WN67FLfZSrrjTEftNZ+pFFDY8wHJa1X30wvu5oQ37jV3t7udgiAYzo6OnTllVe6HQbgKPIcfkCeww/Ic6C1NLvocY+kS9U3mOmHjTF/LOlOSfsrbeZKepmkxTXtrKRfNjlWAAAAAAAwjjX78pYvS6pOWF0taCyR9JeSPl65/WXludo+YcXKazEIpsSClyWTST322GNKJpNuhwI4hjyHH5Dn8APyHGgtTS16WGv3SPqs+goaVn3Fj9pb9flqm89Ya59rZqzjTalUcjsEwDGlUkk9PT3kOTyNPIcfkOfwA/IcaC3N7ukhSe+W9L+q78lh+92qjMrT1v5d06IDAAAAAACe0PSih7W2IOlVkj6g8ows/Xt5VG+nJb1f0qsrrwEAAAAAABixZg9kKkmy1lpJHzPGfErS1ZIuljStsvqYpEck/cJay0AVAAAAAADgrLhS9KiqFDV+VLnhHESjUbdDABwTi8W0cuVKxWIxt0MBHEOeww/Ic/gBeQ60FleLHhg74XDY7RAAx4TDYU2bNm34hsA4Rp7DD8hz+AF5DrQWNwYyhQNyuZzbIQCOyeVy2r9/P3kOTyPP4QfkOfyAPAdaiyM9PYwxP695+J/W2s81eH60rLX2mnOLzLs4qcLLstms9uzZo4kTJyoSibgdDuAI8hx+QJ7DD8hzjHfff/wF/WDLAUVCAb1h43ytmDnB7ZDOiVOXt7xYfVPPbhnk+dEwZ/k6AAAAAAAwQt/ffKB3+YdbDuqh91+jtuj4HRnDrctbBpumttENAAAAAAA0WU+2oCdeOO12GOfEraKHHcUNAAAAAAA4YNHUtiHXF4rj+2u5k0WPwXpqjKaXB709RigUGr/djYDhhEIhTZkyhTyHp5Hn8APyHH5AnmO8ef8rVmj2xLgkacaEqEIBb30Fd+o3cWHNctcgz2MMMQ84vCwej2vVqlVuhwE4ijyHH5Dn8APyHOPNBXMn6v73/YYKxZJCwYA2fvRnOtyVcTusMeNI0cNau3c0z+PclUolt0MAHFMqlVQoFBQKhRQIMNM2vIk8hx+Q5/AD8hzjVSjozXz15k/lQ6lUyu0QAMckk0k98MADSiaTbocCOIY8hx+Q5/AD8hxoLS1Z9DDGTDDGTHM7DgAAAAAAMH41vehhjJlVc5vSb93vGmOelnRK0mFjzAljzD8aY8LNjhMAAAAAAIxvTS16GGMulbS/5vbBmnWvkPQdSUvVN2vLJEnvk/TlZsYJAAAAAADGv2b39LhS9dPQfrdm3Ydqnrc1N/P/2bv38Lju+t73n6+uo5Fk5+I4F+PEMU7i3B3n6tzTtLQQaID2PMDpBdqkUE5PT1oom3Iom4TdQgtNIQ8tvYRCgPQEurt3mrLZbQOFhiQEcnMSJ0Y4jmPjOHGc+K7L6Po9f6w10UgajTSS1qyl9Xu/nmeeWaP1m/l9Nfp4efTVukj6FTPb0KgiAQAAAADA4tfoi0efV7HcJ+mHUnTIi6SLFDU5pInNj7L/U9JDSRe4WHV2dqZdApCYrq4uXXbZZWpubk67FCAx5BwhIOcIATkHsqXRe3qcEt+7pE3uPho/vmzSuH+Q9O+Kmh/lxsfFyZe3eJnZzIOARcrM1NLSQs6Ra+QcISDnCAE5R96Muc88KMMa3fRYpvEmxrMVXz+jYvlhd/81SddJ2hJ/zSSdnHx5i9fAwEDaJQCJ6e/v11NPPcWlmZFr5BwhIOcIATlH3vzOPzyum76+Ud/Z/LLGxhZfAySNpkfZoYrl0yqWfyBJ7j6m6HCWcou0O9nSFrfR0dGZBwGL1OjoqPbv30/OkWvkHCEg5wgBOcdiV2yfeGhW39Co7nniRd341Uf13q89Jl9ke340uulROV9XxXJl06NyD5DDFcvsHwYAAAAAQIKuP3fFtOu+8+OXtXVPbwOrmb9GNz0OxPcm6VJJMrMjJJ1ZMWZLxXJlY6SyAQIAAAAAABbY/3PtGt32znXasPpoVTs1zau9g40vah4affWWrZKWx8unmNkPFDU22irGPFmxfGJ875J2JV8eAAAAAADhMjNdv26Frl+3QnsOl/QLn7tf+/qG0i5rzhq9p8d98b0r2tvjYklnVXztCXffWzH+bI2f+LSnIRUuUm1tbTMPAhap9vZ2rVmzRu3t7WmXAiSGnCME5BwhIOfIk+XdBRVaGt02WFiNrv6LkobjZZ90L0l/U14ws7MlHVOx7pFkS1vcaHogz9ra2rRixQpyjlwj5wgBOUcIyDmQLQ1terj785LeL2lE0Z4e5Zsk/bO7314x/B3xfXn9dxtS5CI1PDw88yBgkRoeHtbLL79MzpFr5BwhIOcIATkHsqXh+6m4+5cUHdLyMUm3S/oLSde5+y9NGvqwpN8q39z98YYWusgMDi6uk8kA9SiVSurp6VGpVEq7FCAx5BwhIOcIATkHsqXRJzKVJLn7s5L+ZIYx/9KgcgAAAAAAQA4t7jOSAAAAAAAATIOmBwAAAAAAyKVEDm8xsy9VPLzX3b9e5ev1cne/YX6V5Vdzc3PaJQCJaW5uVnd3NzlHrpFzhICcIwTkHMiWpM7p8R6NX4r2gKSvV/l6PSx+Hk2PaXR0dKRdApCYYrGo9evXp10GkChyjhCQc4SAnAPZksqJTDV+GVoAAAAAAIBEpHVOD6/zhhn09vamXQKQmMOHD+u+++7T4cOH0y4FSAw5RwjIOUJAzoFsSXJPj+n25mAvDwAAAAAAkLikmh7XVCy/MM3XAQAAAAAAEpNI08Pd76vn6wAAAAAAAAstrXN6AAAAAAAAJCqtq7dggRWLxbRLABLT2dmpiy66SO3t7WmXAiSGnCME5BwhIOdAtjS06WFmx0v6rYovPefu/zDN2F+VtLriS7e7+0tJ1reYNTWx0w7yq6mpSR0dHWmXASSKnCME5BwhIOdAtjR6T4+3SrpZ45ehfXuNsa9K+mrF2Fck/XVilS1ypVJJS5YsSbsMIBEDAwPavn27Vq1axYcI5BY5RwjIOUJAzoFsafTuAW+I703Si+5+z3QD3f3fJO3Q+CVu3zDdWEgjIyNplwAkZmRkRHv27CHnyDVyjhCQc4SAnAPZ0uimx9r43iU9OIvxD1V5LgAAAAAAwIwa3fQ4ThMPV5nJ3vje4ucCAAAAAADMSqObHpUHtS2bxfjKMYUFrgUAAAAAAORYo5se++N7k3SNmU17Had43c9ofM+QAwnXtqi1tramXQKQmLa2Np100klqa2tLuxQgMeQcISDnCAE5B7Kl0U2P5zR+YtJjJP1FjbGfjcdIUePjuQTrWvS4DjjyrL29XatWrSLnyDVyjhCQc4SAnAPZ0uimx/3xvStqfvy2mT1oZu82s4vj27vN7AFJ76sYJ0kPNLjWRYWzQyPPRkZGtG/fPnKOXCPnCAE5RwjIOZAtjW56fEXjh6uUGxqXSPqSpB/Ety9J2qDxZkfZVxtU46JUKpXSLgFIzMDAgDZt2qSBgYG0SwESQ84RAnKOEJBzIFsa2vRw9x5Jd2m8oVFufFS7VTZHvu7umxtZKwAAAAAAWNwavaeHJL1f0jOa2PiodlM8ZnP8HAAAAAAAgFlreNPD3Q9LukzS3Zq4Z0dZ5dfulnS5ux9qdJ0AAAAAAGBxa0lj0riJ8Utmdr6kX5Z0saRj49V7JP1I0j+5+6Np1LcYNTWlsdMO0BhNTU0qFArkHLlGzhECco4QkHMgW1JpepS5+2OSHkuzhrwoFotplwAkprOzUxdffHHaZQCJIucIATlHCMg5kC20HwEAAAAAQC6l3vQws3Vm9n4zu8XMbjWz69OuaTHq6+tLuwQgMb29vfrBD36g3t7etEsBEkPOEQJyjhCQcyBbUju8xczeJelmSWumrrJvKjqvx9Hx1/7D3X+rgeUtOu4+8yBgkXJ3DQ8Pk3PkGjlHCMg5QkDOgWxp+J4eFrld0p2STlGVK7i4+5ik70taFd9+zcyObHStAAAAAABg8Urj8Jb/JukGRU0Or7hN9o/xvUtqlfQLDakOAAAAAADkQkObHma2RtJ/0cRGh00z/GFJ+yseX5NgaQAAAAAAIGcavafH+zR+HhGT1CvpdlVpfHh0ENxTFevObkSBi1VHR0faJQCJKRaLWrduHZdmRq6Rc4SAnCME5BzIlkY3Pa5VtIeHSRqWdLm7vy9eV+0Ql+3xvUk6OfHqFrHm5ua0SwAS09zcrKVLl5Jz5Bo5RwjIOUJAzoFsaXTT46T43iX9u7tvmmF85XWeliZTUj4MDg6mXQKQmMHBQW3dupWcI9fIOUJAzhECcg5kS6ObHl0Vyy/MYvzRFctc86mG4eHhtEsAEjM0NKRdu3ZpaGgo7VKAxJBzhICcIwTkHMiWRjc9Kk9MetK0o8adq/Fmx/5aAwEAAAAAACo1uumxXdH5OUzSz5rZ66cbaGZvlnR6/NAlbUm8OgAAAAAAkBuNbnp8P753Sa2S/tPM3jdpzAoz+4ikb2j8pKeSdH9jSgQAAAAAAHnQ6KbHlzV+uIpLWiHpC/Hj8h4gvyzpjyVVXoN1TNIdjSlxcWppaZl5ELBItba26oQTTlBra2vapQCJIecIATlHCMg5kC0NbXq4+48lfUXje29U7slRVm5+VDZHvuTu2xpS5CJVKBTSLgFITKFQ0CmnnELOkWvkHCEg5wgBOQeypdF7ekjS70j6kSY2PqrdFI/5kaTfa3CNi87o6GjaJQCJGR0d1eHDh8k5co2cIwTkHCEg50C2NLzp4e4Dkq6W9FeSRjS+Z8fk26ikv5b0M/FzUMPAAG8R8qu/v1+PP/64+vv70y4FSAw5RwjIOUJAzoFsSeVEEO4+KOl3zexPJf2ipIslHROv3iPpEUnfdPedadQHAAAAAAAWv1TPfunuuxTtzfHXadYBAAAAAADyp6FNDzOrPBnpoKTz3Z39vgAAAAAAwIJr9J4eKxWdR8Qk/RsNj4VjNvkiOEB+mJmam5vJOXKNnCME5BwhIOdAtjS66fGypOMVXZ1le4PnzrXOzs60SwAS09XVpcsvvzztMoBEkXOEgJwjBOQcyJZGX73lYY1fqvboBs8NAAAAAAAC0uimx9/E9ybpDWZ2VIPnr8rMTjKzW82sx8z6zGyfmT1iZh8ys2JCcxbNbJuZeXzbPp/X45JYyLO+vj498sgj6uvrS7sUIDHkHCEg5wgBOQeypaFND3e/V9Jt8cMlkv6XmZ3UyBomM7O3SHpK0gcknSapKOlISRdI+rSkjWa2JoGpPyHp5IV6sbGxsYV6KSBzxsbG1N/fT86Ra+QcISDnCAE5B7Kl0Vdv+a+S9kt6QdLrJF0s6Vkzu19R4+GAovN9VOXun1jges6T9A1JHZJ6JX1K0vfix++U9FuSTpX0LTO7wN0PL+C8vyepJGlYUvdCvC4AAAAAABjX6BOZ3qzxpoYrOsylRdLV8W0mC9r0ULTXSYekEUlvcPeHKtZ918yeVbS3x6mSPqio/nkxs2ZJt0tqlnSLpBtE0wMAAAAAgAXX6HN6lFl8c403P2a6LWwBZhdJuiJ++PeTGh5lt0r6cbx8k5m1LsDUN0k6X9JPJP3ZArweAAAAAACoIq2mR7nZMfnxdLckvLVi+cvVBrj7mKSvxg+PkHTNfCaMz19S3lvlt919aD6vV6lQKCzUSwGZ09HRoTPPPFMdHR1plwIkhpwjBOQcISDnQLak0fSYzV4die7lEStfPLtP0mM1xt1XsXzZPOf8gqROSV9z9/+c52tN0NLS6COVgMZpaWnRsmXLyDlyjZwjBOQcISDnQLY0+l/ibzR4vlpOj++3uvtIjXE9VZ5TNzN7p6Q3KTqR6wfn+jrTGRpasJ1GgMwZGhrS7t27ddxxx6mtrS3tcoBEkHOEgJwjBOQcyJaGNj3c/SuNnG86ZlaQtCx++EKtse6+38z6FO2hsXKO8x0p6XPxwz9091fm8jq17Nu3b8aN6pIlSxZ6WqAhBgcH9fzzz+vII4/kwwNyi5wjBOQcISDnQLY0+pK1zZKOllRy90ONnHuSyqul9M5ifLnp0TXH+T4j6VhJDym6csuCu+uuu2Yc84EPfOC15e7u6C3o7+/X6OjohHGFQkGtra0aGhrS4ODghHXNzc0qFotyd/X2Tn3rOjs71dTUpIGBAY2MTNyBpr29XW1tbRoeHlapVJqwrqmpSZ2dnZKkw4enXhm4WCyqublZpVJJw8PDE9a1tbWpvb1dIyMjGhgYmLDOzNTVFf3Yent75T7xFDEdHR1qaWnR4ODglL1lWltbVSgUNDo6qv7+/ik1ld/Dvr6+Kddhr/UetrS0qKOjQ2NjY+rr65vyul1dXTKzqj+bWu9h+WcjVX8Pa/1sar2HlT+bau9h+WdT73tY+bOp9h6WfzZDQ0OvPbd8P5/3sPyzqfUeziff83kPa+V7Pu9htZ/NTO8h24hII7cR5dcYHBxUd3c324g6thELuZ1lGxFJahtRfk/dve4chr6NKONzRCTr2whJU2pmGxHhc0RkMW0jxiZ9X5Pf36xLvOlhZibpNyXdKOkCxecRMbN9kv63pE+5e8/0r5CIyrN+zua4kHKS6j4bkZldqej7H1F08tKkTsw6o8cff/y15auuukqS1NPTM+Uf/tq1a3XsscfqlVde0datWyesO/LII3XOOedodHR0wuuVbdiwQW1tbXruuee0d+/eCetWr16tlStX6sCBA9q8efOEdV1dXTr//PMlSRs3bpyywbjgggvU2dmpHTt2aPfu3RPWrVy5UqtXr1Zvb6+efPLJCeva2tq0YcMGSdKmTZumbGzOPfdcHXHEEdq1a5d27tw5Yd1xxx2n0047TaVSacr3ama68sorJUXv4eSN8hlnnKFjjjlGL7/8srZt2zZh3dFHH62zzjpLIyMjVd/Dyy67TC0tLdq6dav2798/Yd2aNWu0YsUK7du3Tz09E//ZdHd3a/369ZJU9XUvuugidXR0aPv27dqzZ8+EdSeddJJWrVqlQ4cOadOmTRPWFQoFXXzxxZKkp556asp/BOvWrdPSpUu1c+dO7dq1a8K6E044Qaeccor6+/un1NTc3KzLL49OrbN58+YpG/szzzxTy5Yt0+7du/X8889L0mvf87Jly3TmmWdqeHi46vd6xRVXyMy0ZcsWHTx4cMK6U089Vccff7xeffVVbdmyZcK6pUuXat26dXL3qq97ySWXqL29Xdu2bdOrr746Yd3JJ5+sE088UQcOHNAzzzwzYV2xWNSFF14oSXriiSem/Aezfv16dXd3a+fOnXrxxRcnrFuxYoXWrFmj3t5ePfHEExPWtba26tJLL5UkPf3001P+Azr77LN11FFH6aWXXtKOHTsmrFu+fLlOP/10DQ4OVv1e2UZE0thGvPDCC1q2bBnbiDlsI8rYRkSyuI0of4gfGxub8u9RYhtRxueIyGLeRkia8h6zjYjwOSKymLYRk7+v7du3T3ndLLMkfwc3s6KkuyX9bPlLk4a4ombAu93964kVMrWuYySVt9bfcPd3zjD+ZUnLJT3t7mfXMU+7pCclnSbpVnf/gypjtks6SdIOd18129eWpFtuueV1knZK0tve9jYtW7bstXUtLS0qFAoaGxt77T+B8geNymW6r/novkr5/gvN/v371dPTo7Vr16pYLPJX3DrfQ/5Cszi2Ef39/erp6XntgzrbiGz/FZdtxNz39Ni8ebPOO+88RX8Xm4htRITPEZHFuo04dOiQNm7c+Nrnltm8h2wjInyOGJelbcTPff5H2n1ofJ7brj9ZT9z738sPV3784x+vecqItCXd9PiSpPdUfGnyZOX/7YYlbXD3qa2oZOoqSCon9lvu/uYZxvcqOrzlh+6+oY55PiHpY4oaE6e7+5TULVTT4/3vf7+WL19ez9OBRWNgYEDbtm3T6tWrufwbcoucIwTkHCEg58ibSz/1H3rx4HgT5G/fcbp++C9fKz/MfNMjscNbzOxsRQ2PWl2V8rpWSZ/W+B4hiXL3kpntVXR+kdfVGhufhLQzfriz1tgqPhzff0fSW6r9RaPitTvjK7xI0h53/249ExUKhZkHAYtU+Xr3QJ6Rc4SAnCME5BzIliTP6fHuKl+rdnhL2TVmttLd620szNVmSVdIWmNmLTUuW7u2YvnHdc5RPl3zb2jmy/Uuk1Q+G+l9kupqekze5QnIk7GxMQ0PD6u1tVVNTU1plwMkgpwjBOQcISDnQLYk+a/w0oplk7Rf0kclvUXSr0u6R1ObILM+dGQBPBDfd0o6v8a4qyqWH0yunPmpdhwYkBd9fX364Q9/WPW4RCAvyDlCQM4RAnIOZEuSTY/XK9qTwySVJF3q7p9y92+5+53u/jZJf6WJjY/XJ1jPZP9csVx1Lwwza1LUoJGkA5K+V88E7m4z3SSVT4W8o+LrV9f5vQAAAAAAgEmSbHosje9d0nfcfUuVMZ+rGCNJRyRYzwTu/rCk++OHN5hZtb1MPijp9Hj5NnefcCpfM7vazDy+3ZFctQAAAAAAoF5JntOjTePNjOenGbNt0uPW5Mqp6iZFh6x0SLrXzD6paG+ODknvlPTeeNwWSbc2uDYAAAAAADAPSTY9Ko1W+6K7+zRXNGkId99oZu+QdKekJZI+WWXYFknXufvUCzoDAAAAAIDMalTTI7Pc/Ztmdo6ivT6uU3QJ2yFJWyX9d0l/6e6ZP0toZ2fnzIOARaqrq0tXXHGF0mySAkkj5wgBOUcIyDmQLY1qevyyma2b5zh392sXsqiKF94h6QPxrZ7n/aemXoGm3rlXzef5ZWxUkWdmRsaRe+QcISDnCAE5B7KlEU0Pk7QivtUaoxrjTOPnB0EVAwMDWrJkSdplAIno7+/Xli1bdOqpp6pYLKZdDpAIco4QkHOEgJwD2dKoPT1m2+qsNo5mxyyMjlY9bQqQC6Ojozp48CA5R66Rc4SAnCME5BzIlkY0PWhaAAAAAACAhku66cHBbAAAAAAAIBVJNj1uSfC1AQAAAAAAakqs6eHuND0aqL29Pe0SgMQUCgWdeuqpKhQKaZcCJIacIwTkHCEg50C2NOpEpkhYa2tr2iUAiWltbdXxxx+fdhlAosg5QkDOEQJyDmRLU9oFYGEMDw+nXQKQmOHhYb300kvkHLlGzhECco4QkHMgW2h65MTg4GDaJQCJKZVK2rJli0qlUtqlAIkh5wgBOUcIyDmQLTQ9AAAAAABALtH0AAAAAAAAuUTTAwAAAAAA5BJNj5xobm5OuwQgMc3NzVq6dCk5R66Rc4SAnCME5BzIFi5ZmxMdHR1plwAkplgsat26dWmXASSKnCME5BwhIOdAtrCnR064e9olAIlxd42NjZFz5Bo5RwjIOUJAzoFsoemRE319fWmXACSmt7dX999/v3p7e9MuBUgMOUcIyDlCQM6BbKHpAQAAAAAAcommBwAAAAAAyCWaHgAAAAAAIJdoegAAAAAAgFzikrU5USwW0y4BSExnZ6cuueQStba2pl0KkBhyjhCQc4SAnAPZQtMjJ5qa2GkH+dXU1KT29va0ywASRc4RAnKOEJBzIFv4TTknSqVS2iUAiRkYGNAzzzyjgYGBtEsBEkPOEQJyjhCQcyBbaHrkxMjISNolAIkZGRnRq6++Ss6Ra+QcISDnCAE5B7KFpgcAAAAAAMglmh4AAAAAACCXaHoAAAAAAIBcoumRE21tbWmXACSmvb1dJ598MmdCR66Rc4SAnCME5BzIFi5ZmxM0PZBnbW1tOvHEE9MuA0gUOUcIyDlCQM6BbGFPj5zg7NDIM86CjhCQc4SAnCME5BzIFpoeOVEqldIuAUgM17tHCMg5QkDOEQJyDmQLTQ8AAAAAAJBLND0AAAAAAEAu0fQAAAAAAAC5RNMjJ5qa+FEiv5qamlQsFsk5co2cIwTkHCEg50C2cMnanCgWi2mXACSms7NTF154YdplAIki5wgBOUcIyDmQLbQfAQAAAABALtH0yIm+vr60SwAS09vbqwceeEC9vb1plwIkhpwjBOQcISDnQLbQ9MgJd0+7BCAx7q7R0VFyjlwj5wgBOUcIyDmQLTQ9AAAAAABALtH0AAAAAAAAuUTTAwAAAAAA5BJNj5zo6OhIuwQgMcViUevXr+fSzMg1co4QkHOEgJwD2dKSdgFYGM3NzWmXACSmublZ3d3daZcBJIqcIwTkHCEg58i7/X3DaZdQF/b0yIlSqZR2CUBiSqWSnn32WXKOXCPnCAE5RwjIOfLmdUdN3Gvpjh9sT6eQOaLpkRMjIyNplwAkZnh4WC+++KKGhxdXVxmoBzlHCMg5QkDOkTe/eslJEx7/dF9/SpXMDU0PAAAAAABQ1VvOOV7rVh6RdhlzRtMDAAAAAABUZWb62JtPT7uMOaPpAQAAAAAApnX+SUfpurOPT7uMOaHpkROtra1plwAkpq2tTStWrFBbW1vapQCJIecIATlHCMg58urDv7BWbc2Lr4Ww+CpGVe3t7WmXACSmvb1da9asIefINXKOEJBzhICcI69OPLqo91y2Ku0y6kbTIydGR0fTLgFIzOjoqA4ePEjOkWvkHCEg5wgBOUee/c41a1RsW1xthMVVLaY1MDCQdglAYvr7+/XEE0+ov39xXR4LqAc5RwjIOUJAzpFnSztataRjcR26RdMDAAAAAADkEk0PAAAAAACQSzQ9AAAAAABALtH0yAkzS7sEIDFmptbWVnKOXCPnCAE5RwjIOZAtLWkXgIXR2dmZdglAYrq6unTppZemXQaQKHKOEJBzhICcA9nCnh4AAAAAACCXaHrkBJfEQp719fXpRz/6kfr6+tIuBUgMOUcIyDlCQM6BbKHpkRNjY2NplwAkZmxsTKVSiZwj18g5QkDOEQJyDmQLTQ8AAAAa2oRjAAAgAElEQVQAAJBLND0AAAAAAEAu0fQAAAAAAAC5RNMjJwqFQtolAInp6OjQ2WefrY6OjrRLARJDzhECco4QkHMgW1rSLgALo6WFHyXyq6WlRUcddVTaZQCJIucIATlHCMg5kC3s6ZETg4ODaZcAJGZwcFDbt28n58g1co4QkHOEgJwD2ULTIyeGh4fTLgFIzNDQkHbs2KGhoaG0SwESQ84RAnKOEJBzIFtoegAAAAAAgFyi6QEAAAAAAHKJpgcAAAAAAMglmh45wdVbkGctLS1avnw5OUeukXOEgJwjBOQcyBb+JeZEoVBIuwQgMR0dHTr99NPTLgNIFDlHCMg5QkDOgWxhT4+cGBsbS7sEIDFjY2MaGBgg58g1co4QkHOEgJwD2ULTIyf6+/vTLgFITF9fnx5++GH19fWlXQqQGHKOEJBzhICcA9lC0wMAAAAAAOQSTQ8AAAAAAJBLND0AAAAAAEAu0fQAAAAAAAC5xCVrc6KrqyvtEoDEdHd366qrrkq7DCBR5BwhIOcIATkHsoU9PQAAAAAAQC7R9MiJgYGBtEsAEtPf36/HH3+cSzMj18g5QkDOEQJyDmQLTY+cGB0dTbsEIDGjo6M6fPgwOUeukXOEgJwjBOQcyBaaHgAAAAAAIJdoegAAAAAAgFyi6QEAAAAAAHKJpkdOtLe3p10CkJhCoaC1a9eqUCikXQqQGHKOEJBzhICcA9nSknYBWBitra1plwAkprW1Vccee2zaZQCJIucIATlHCMg5kC3s6ZETQ0NDaZcAJGZoaEi7du0i58g1co4QkHOEgJwD2ULTIyfYqCLPBgcHtXXrVg0ODqZdCpAYco4QkHOEgJwD2ULTQ5KZnWRmt5pZj5n1mdk+M3vEzD5kZsV5vnbRzN5uZn8dv+Z+Mxs2s71m9pCZ3Wxmxy3U9wIAAAAAACLBn9PDzN4i6U5JSyq+XJR0QXy70cyuc/etc3jtcyQ9KKmryuqjJF0S337fzN7r7t+odw4AAAAAAFBd0Ht6mNl5kr6hqOHRK+mjki6VdK2k2+Nhp0r6lpl1z2GKJRpveDwo6SOSfk7Sekk/L+lvJY3F4/7BzN44t+8EAAAAAABMFvqeHrdJ6pA0IukN7v5Qxbrvmtmzkj6tqPHxQUk31/n6Y5L+UdIt7r65yvp7zexfJd0tqVnS583sFHf3OudRc3NzvU8BFo3m5mYdeeSR5By5Rs4RAnKOEJBzIFuC3dPDzC6SdEX88O8nNTzKbpX043j5JjOr67qw7v4Dd3/HNA2P8ph7JP3P+OHrJZ1XzxxlHR0dc3kasCgUi0Wdc845KhbndYodINPIOUJAzhECcg5kS7BND0lvrVj+crUB7j4m6avxwyMkXZNQLd+rWH79XF5gDjuHAIuGu2tkZIScI9fIOUJAzhECcg5kS8hNj8vj+z5Jj9UYd1/F8mUJ1dJesTw6lxfo6+tboFKA7Ont7dWDDz6o3t7etEsBEkPOEQJyjhCQcyBbQj6nx+nx/VZ3H6kxrqfKcxbaVRXLP552VA29vb06dOhQzTFLliypuR4AAAAAgDwJsulhZgVJy+KHL9Qa6+77zaxPUqeklQnUcq6k6+KHm9x9Tk2Pu+66a8YxH/jAB15b7u6OLkbT39+v0dGJO5cUCgW1trZqaGhIg4ODE9Y1NzerWCzK3at2rzs7O9XU1KSBgQGNjEzsJbW3t6utrU3Dw8MqlUoT1jU1Namzs1OSdPjw4SmvWywW1dzcrFKppOHh4Qnr2tra1N7erpGREQ0MDExYZ2bq6oouoNPb2ztlN8OOjg61tLRocHBQQ0NDE9a1traqUChodHRU/f39U2oqv4d9fX0aGxubsK7We9jS0qKOjg6NjY1V3UOnq6tLZlb1Z1PrPSz/bKTq72Gtn02t97DyZ1PtPSz/bOp9Dyt/NtXew/LPZmho6LXnlu/n8x6Wfza13sP55Hs+72GtfM/nPaz2s5npPWQbEWnkNqL8GoODg+ru7mYbUcc2YiG3s2wjIkltI8rvqbvXncPQtxFlfI6IZH0bIWlKzWwjInyOiCzmbUR0FojFI8imh6TKy8/OZr+zctOja6aB9TCzdklfVHTlFim6ZG5iHn/88deWr7oq2rmkp6dnyj/8tWvX6thjj9Urr7yirVu3Tlh35JFH6pxzztHo6OiE1yvbsGGD2tra9Nxzz2nv3r0T1q1evVorV67UgQMHtHnzxHO7dnV16fzzz5ckbdy4ccoG44ILLlBnZ6d27Nih3bt3T1i3cuVKrV69Wr29vXryyScnrGtra9OGDRskSZs2bZqysTn33HN1xBFHaNeuXdq5c+eEdccdd5xOO+00lUqlKd+rmenKK6+UFL2HkzfKZ5xxho455hi9/PLL2rZt24R1Rx99tM466yyNjIxUfQ8vu+wytbS0aOvWrdq/f/+EdWvWrNGKFSu0b98+9fT0TFjX3d2t9evXS1LV173ooovU0dGh7du3a8+ePRPWnXTSSVq1apUOHTqkTZs2TVhXKBR08cUXS5KeeuqpKf8RrFu3TkuXLtXOnTu1a9euCetOOOEEnXLKKerv759SU3Nzsy6/PDrKbPPmzVM29meeeaaWLVum3bt36/nnn5ek177nZcuW6cwzz9Tw8HDV7/WKK66QmWnLli06ePDghHWnnnqqjj/+eL366qvasmXLhHVLly7VunXr5O5VX/eSSy5Re3u7tm3bpldffXXCupNPPlknnniiDhw4oGeeeWbCumKxqAsvvFCS9MQTT0z5D2b9+vXq7u7Wzp079eKLL05Yt2LFCq1Zs0a9vb164oknJqxrbW3VpZdeKkl6+umnp/zndPbZZ+uoo47SSy+9pB07dkxYt3z5cp1++ukaHBys+r2yjYiksY144YUXtGzZMrYRc9hGlLGNiGRxG1H+ED82Njbl36PENqKMzxGRxbyNkDTlPWYbEeFzRGQxbyMm/zvOOgvxBDtmtlLST+OHX3P3X59h/E8V7eXxnLuvWcA6bpd0Y/zwK+7+nnqef8stt7xO0k5Jetvb3qZly5a9tq6lpUWFQkFjY2Ov/SdQ/qBRuUz3NZ/d17z9hWb//v3q6enR2rVrVSwW+Stune8hf6FZHNuI/v5+9fT0vPZBnW1Etv+KyzZi7nt6bN68Weedd57MbMrrso2I8Dkisli3EYcOHdLGjRtf+9wym/eQbUSEzxHjsryNuOaT39LVw4+WV638+Mc/XvPoibSF2vQ4RlK5Rf0Nd3/nDONflrRc0tPufvYC1fARSZ+MHz4i6Rp3r+tspJVNj5tuuklHHHHEQpQGZM7Y2JhGRkbU0tKipqaQz7+MPCPnCAE5RwjIOfLuZz71r7pq6OHyw8w3PUI9vKWyvTebQ1Y64/sFOQWzmb1P4w2PHklvqrfhMRkbVORZU1OT2tra0i4DSBQ5RwjIOUJAzoFsCfI3ZXcvSSofBPa6WmPN7EiNNz121ho7G2b2LklfiB/ukPRz7v5qjafMyuTdj4A8GRgY0NNPPz1ll0IgT8g5QkDOEQJyDmRLkE2PWPnsNmvMrNYeL2srlud0ZZUyM/tFSV9V9L6/JOlad1+QXYEmH9MG5MnIyIj27t1LzpFr5BwhIOcIATkHsiXkpscD8X2npPNrjLuqYvnBuU5mZtdK+kdFhxTtVbSHx3NzfT0AAAAAAFBbyE2Pf65Y/o1qA8ysSVL5yi4HJH1vLhOZ2aWS7pHULumgpJ9392dqPwsAAAAAAMxHsE0Pd39Y0v3xwxvMbEOVYR+UdHq8fJu7T7h+kZldbWYe3+6oNo+ZrZP0LUV7lPRJus7dH1uI7wEAAAAAAEwv1Ku3lN2k6JCVDkn3mtknFe3N0SHpnZLeG4/bIunWel/czF4v6d8lla8l+0eSDprZWTWetsfd99RYXxVniEaetbe3a/Xq1Wpvb0+7FCAx5BwhIOcIATkHsiXopoe7bzSzd0i6U9ISjV9GttIWRXtnHK6ybiZXSFpe8fizs3jOLZJurncimh7Is7a2Nq1cuTLtMoBEkXOEgJwjBOQcyJZgD28pc/dvSjpHUUNii6R+RefveFTShyWd5+5b06twdoaHh2ceBCxSw8PDeuWVV8g5co2cIwTkHCEg50C2BN/0kCR33+HuH3D309y9092PdPcL3f3T7t5f43n/6e4W395TZf0dFetne7t5Lt/D4ODgXJ4GLAqlUkmbN29WqVRKuxQgMeQcISDnCAE5B7KFpgcAAAAAAMglmh4AAAAAACCXaHoAAAAAAIBcoumRE01N/CiRX01NTerq6iLnyDVyjhCQc4SAnAPZEvQla/OkWCymXQKQmM7OTp1//vlplwEkipwjBOQcISDnQLbQfgQAAAAAALlE0yMnent70y4BSMzhw4f1/e9/X4cPH067FCAx5BwhIOcIATkHsoWmB4BFwd3TLgFIHDlHCMg5QkDOgeyg6QEAAAAAAHKJpgcAAAAAAMglmh4AAAAAACCXuGRtTnR0dKRdApCYYrGoCy64QIVCIe1SgMSQc4SAnCME5BzIFpoeOdHc3Jx2CUBimpub1dnZmXYZQKLIOUJAzhECcg5kC4e35ESpVEq7BCAxpVJJP/nJT8g5co2cIwTkHCEg50C20PTIiZGRkbRLABIzPDys3bt3a3h4OO1SgMSQc4SAnCME5BzIFpoeAAAAAAAgl2h6AAAAAACAXKLpAQAAAAAAcommR060tramXQKQmLa2Nq1cuVJtbW1plwIkhpwjBOQcISDnQLZwydqcaG9vT7sEIDHt7e1avXp12mUAiSLnCAE5RwjIOZAt7OmRE1y9BXk2MjKiAwcOkHPkGjlHCMg5QkDOgWyh6ZETXAcceTYwMKAnn3xSAwMDaZcCJIacIwTkHCEg50C20PQAAAAAAAC5RNMDAAAAAADkEk0PAAAAAACQSzQ9csLM0i4BSIyZqa2tjZwj18g5QkDOEQJyDmQLl6zNic7OzrRLABLT1dWlDRs2pF0GkChyjhCQc4SAnAPZwp4eAAAAAAAgl2h65ERfX1/aJQCJ6e3t1UMPPaTe3t60SwESQ84RAnKOEJBzIFtoeuSEu6ddApAYd9fQ0BA5R66Rc4SAnCME5BzIFpoeAAAAAAAgl2h6AAAAAACAXKLpAQAAAAAAcommR04UCoW0SwAS09HRoXPPPVcdHR1plwIkhpwjBOQcISDnQLa0pF0AFkZLCz9K5FdLS4uOOOKItMsAEkXOEQJyjhCQcyBb2NMjJwYHB9MuAUjM4OCgtm3bRs6Ra+QcISDnCAE5B7KFpkdODA8Pp10CkJihoSHt3LlTQ0NDaZcCJIacIwTkHCEg50C20PQAAAAAAAC5RNMDAAAAAADkEk0PAAAAAACQSzQ9coKrtyDPWltbddxxx6m1tTXtUoDEkHOEgJwjBOQcyBZ+U86JQqGQdglAYgqFgk477bS0ywASRc4RAnKOEJBz5F1Xe7O0iM7Ty54eOTE6Opp2CUBiRkdH1dfXR86Ra+QcISDnCAE5R97deeMlaZdQF5oeOTEwMJB2CUBi+vv79eijj6q/vz/tUoDEkHOEgJwjBOQcyBaaHgAAAAAAIJdoegAAAAAAgFyi6QEAAAAAAHKJpgeARcHM0i4BSBw5RwjIOUJAzoHs4JK1OdHV1ZV2CUBiuru7deWVV6ZdBpAoco4QkHOEgJwD2cKeHgAAAAAAIJdoeuQEl8RCnvX19emxxx5TX19f2qUAiSHnCAE5RwjIOZAtND1yYmxsLO0SgMSMjY2pt7eXnCPXyDlCQM4RAnIOZAtNDwAAAAAAkEs0PQAAAAAAQC7R9AAAAAAAALlE0yMn2tvb0y4BSEyhUNAZZ5yhQqGQdilAYsg5QkDOEQJyDmRLS9oFYGG0tramXQKQmNbWVh1zzDFplwEkipwjBOQcISDnQLawp0dODA0NpV0CkJihoSHt3LmTnCPXyDlCQM4RAnIOZAtNj5xgo4o8Gxwc1LZt2zQ4OJh2KUBiyDlCQM4RAnIOZAtNDwAAAAAAkEs0PQAAAAAAQC7R9AAAAAAAALlE0yMnWlq4EA/yq6WlRUcffTQ5R66Rc4SAnCME5BzIFv4l5gTXAUeedXR06Kyzzkq7DCBR5BwhIOcIATkHsoU9PXJibGws7RKAxIyNjWloaIicI9fIOUJAzhECcg5kC02PnOjv70+7BCAxfX19euihh9TX15d2KUBiyDlCQM4RAnIOZAtNDwAAAAAAkEs0PQAAAAAAQC7R9AAAAAAAALlE0wMAAAAAAOQSl6zNic7OzrRLABLT1dWlyy67TM3NzWmXAiSGnCME5BwhIOdAttD0yAkzS7sEIDFmppYWNlfIN3KOEJBzhICcA9nC4S05MTAwkHYJQGL6+/v11FNPcWlm5Bo5RwjIOUJAzoFsoemRE6Ojo2mXACRmdHRU+/fvJ+fINXKOEJBzhICcA9lC0wMAAAAAAOQSTQ8AAAAAAJBLND0AAAAAAEAu0fTIiba2trRLABLT3t6uNWvWqL29Pe1SgMSQc4SAnCME5BzIFq6llBM0PZBnbW1tWrFiRdplAIki5wgBOUcIyDmQLezpkRPDw8NplwAkZnh4WC+//DI5R66Rc4SAnCME5BzIFpoeOTE4OJh2CUBiSqWSenp6VCqV0i4FSAw5RwjIOUJAzoFsoekBAAAAAAByiaYHAAAAAADIJZoeAAAAAAAgl2h65ERzc3PaJQCJaW5uVnd3NzlHrpFzhICcIwTkHMgWLlmbEx0dHWmXACSmWCxq/fr1aZcBJIqcIwTkHCEg50C2sKcHAAAAAADIJZoeOdHb25t2CUBiDh8+rPvuu0+HDx9OuxQgMeQcISDnCAE5B7KFpgcAAAAAAMglzumxuB1XXmBPD+TVoUOH9NnPflaSdMopp6i7uzvlioCFR84RAnKOEJBzhGDSXkzHSXohpVJmhT09JJnZSWZ2q5n1mFmfme0zs0fM7ENmVlzAed5oZneb2QtmNhjf321mb1yoOQAAAAAAQCT4PT3M7C2S7pS0pOLLRUkXxLcbzew6d986jzmaJP2dpBsmrVoR395qZl+U9D53H5vrPAAAAAAAYFzQe3qY2XmSvqGo4dEr6aOSLpV0raTb42GnSvqWmc1n37Q/0XjDY6Okd0m6KL7fGH/9Rkl/PNcJuGQtQlAsLtiOV0BmkXOEgJwjBOQcyIbQ9/S4TVKHpBFJb3D3hyrWfdfMnpX0aUWNjw9KurneCczsVEl/ED98VNKV7j4QP37EzP5F0n2K9ir5kJl9aS57lTQ1Bd2/QiDIOUJAzhECco4QkHMgG4L9l2hmF0m6In7495MaHmW3SvpxvHyTmbXOYarf03hz6XcrGh6SJHfvl/S78cMWSb8/hzk0ODg4l6cBi0qpVEq7BCBx5BwhIOcIATkHsiHYpoekt1Ysf7nagPj8Gl+NHx4h6Zp6JjAzk3R9/LDH3X84zTw/lPST+OH18fPqMjIyUu9TgEWHnCME5BwhIOcIATkHsiHkpsfl8X2fpMdqjLuvYvmyOuc4WdIJVV6n1jwrJK2qcx4AAAAAADBJyOf0OD2+3+rutdqwPVWeM1tnTPM6s5nn+Vm8fnN5Ye/evdq1a1fNwVwnHItR5XXAe3t7dejQoRSrAZJBzhECco4QkHOEoK+vr/Jh83TjsiLIpoeZFSQtix++UGusu+83sz5JnZJW1jnV6yqWa84jaWfF8mznObq8cO+99862JmDRuuuuu9IuAUgcOUcIyDlCQM4RiKNnHpKuUA9vqdzloXcW48utrK4E56lsl812nj31lQMAAAAAwILJ/O+kQe7pIalQsTw0i/HlS6N0JDhP5eVXZjvPJkkXSlouaa+k0RnG757l6wIAAAAAUE2zpGPi5U1pFjIboTY9Kq8f1TaL8e3x/UDNUfObp71ieVbzfPzjHx+U9GidNQEAAAAAMB870i5gtkI9vOVwxfJsDiXpjO9ncyjMXOfprFiudx4AAAAAADBJkE0Pdy8pOhxEmniy0SnM7EiNNyR21hpbReXJS2vOo4knL613HgAAAAAAMEmQTY/Y5vh+jZnVOsxnbcXyj+c4x+TXWeh5AAAAAADAJCE3PR6I7zslnV9j3FUVyw/WOcfzkl6s8jrVXBnf75K0vc55AAAAAADAJCE3Pf65Yvk3qg0wsyZJvx4/PCDpe/VM4O4u6Z744Vozu2SaeS7R+J4e98TPAwAAAAAA8xBs08PdH5Z0f/zwBjPbUGXYByWdHi/f5u7DlSvN7Goz8/h2xzRTfU7jl5L9vJlNuBxt/Pjz8cOReDwAAAAAAJinYJsesZsUXR62RdK9ZvYRM7vEzK4xs7+V9Ol43BZJt85lAnffIukz8cMLJD1oZu8wswvM7B2KDpm5IF7/GXd/dq7fDAAAAAAAGGehH0lhZm+RdKekJdMM2SLpOnffWuW5V2v8kJevuPt7ppmjSdLtkn6zRil/L+m97j42u8oBAAAAAEAtoe/pIXf/pqRzJH1WUYOjX9H5Ox6V9GFJ51VreNQ5x5i73yDpOkXn+HhR0lB8f4+k90g6KGmzmfWZ2T4ze8TMPmRmxfnMXcnM3mhmd5vZC2Y2GN/fbWZvXKg5gOmY2UlmdquZ9Sx0zs2saGZvN7O/jl9zv5kNm9leM3vIzG42s+MW6nsBppNkzmvMWTSzbRWHW25PYh6grJE5N7OfNbM7zGxrPNdBM9tiZv9kZu83s66FnA8oa0TOzWyVmf2ZmT1mZgfizy77zOwHZvZfzWz5QswDVDKz5Wb2ZjP7hJn9q5m9OotTNsx3zneZ2b1mttvMSma2w8zunOYUEws/f+h7eqRtPnua1DFHk6S/k3RDjWFflPQ+9jRBEpLMuZmdo+gwsZk++B5StDfVN+qdA5iNRmzPp5n3zxWdg6psh7uvWsg5gLJG5dzMjpT0ZUnXzzD0PHd/Yj5zAZM16PP5r0n6W0kdNYbtk/ROd//2XOcBJjOzWg2AaY9emONcHZL+SdKbphkyJukT7n7LQs1ZTfB7eqTJzM6T9A1FG9ReSR+VdKmkaxUdDiNJp0r6lpl1z2OqP9F4w2OjpHdJuii+3xh//UZJfzyPOYCqGpDzJRpveDwo6SOSfk7Sekk/r+gDxVg87h/YswlJaOD2vNq8vyepJOnwQr0uUE2jcm5mSyV9W+MNj7sl/YqkSyRdKOntkm6T9MJc5wCm04icm9llku5Q1PAYU9Tge6uiz+e/LOmb8dCjJN1jZqvnMg8wCz+VdG+Cr/8ljTc8vqfxnN8g6TlF/Yibzey9CdYguTu3lG6Svi/JJQ1L2lBl/Yfi9S7p5jnOcWr8+i7pEUkdk9YX46+X61iT9vvCLV+3pHOu6IPINySdUWPM9Yo+VLikrYr3cuPGbaFujdieV3nNZkWHYrqkj0naHi9vT/v94JbPW6NyLumr8WuUJP1ijXEmqSXt94Vbvm4N+nz+vype4/+aZsytFWP+Mu33hVt+bpJukfRmScfGj1dVZO2OBZznZype918kNU9av0zSjnj9fklHJvU9c3hLSszsIkk/ih/+rbv/dpUxTZKeVnTZ3AOSlvuky+bOYp4vSHp//HCDu/+wyphLJD0UP/yCu/9OPXMA02lUzmdZyz9J+qX44fnu/vhCz4EwpZVzM/uAog/FP1F0bqotkk4Sh7cgAQ383HK5pPvjhx9y9z+fe9VAfRqY832SjpS0192XTTNmafz6kvS4u59fzxzAbJnZKknPxw8X7PAWM/vfkt4oaUTSye4+Ze88M3unpLvih//F3T8zecxC4PCW9Ly1YvnL1QZ4dH6Nr8YPj5B0TT0TmJlpfNfQnmoNj3ieHyr60CxJ18fPAxZC4jmvw/cqll+f0BwIU8NzbmYnSfpE/PC33X1oPq8HzEKjcv5/x/cHJf3lHJ4PzEejct4W3z8/3QB3Pyjp1UnjgUUhPvTr2vjhd6o1PGL/U9F59yTpbUnVQ9MjPZfH932SHqsx7r6K5cvqnONkSSdUeZ1a86xQtIsTsBAakfPZaq9YHk1oDoQpjZx/QVKnpK+5+3/O87WA2Ug852bWpvE/1nzb3Uvx15vNbGV8pYtCPa8J1KlR2/PyHxtPnm6AmS1RtPt/5XhgsbhQ4826aX8Pjf9oU/7D/IVm1ppEMTQ90nN6fL/V3UdqjOup8pzZOmOa11noeYDpNCLns3VVxfKPE5oDYWpozuNdQd+k6PjXD84wHFgojcj5uZLKTY1NZrbEzD6n6K/dP1X0V/GDZvZtM7u6ztcGZqNR2/O/ie+PNrMph9DEPlZlPLBYzOX30BZJpyRRDE2PFMR/pSh3bmueedzd9yvqNkvSyjqnel3F8kxnON9ZsVzvPMAUDcz5bGo5V9J18cNN7k7TAwui0TmPL+P5ufjhH7r7K3N5HaAeDcx55YfkJkUn6r1J0SEEZW2SflbSd83sw3W+PjCtBm/Pv6TxQ2T+ysxuN7O3mNkFZvZ2M7tb0h/E6//E3b8zhzmANGXq91CaHumovLxV7yzGlzeqXTVHzW+evorleucBqmlUzmsys3ZJX1R0pQspuvQcsFAanfPPSDpW0cmnb59hLLBQGpXzoyqWP6zoL37/pujyhgVJyxWdnP2goiu3/KmZXT/5RYA5atj23N1H3f3dkv4PSU9KulHR1S0ekfQ/FJ1b5HuSfs7d/6je1wcyIFO/h9L0SEfl8aizOfncYHzfkeA8gxXL9c4DVNOonM/kLyVdEC9/xd2/ucCvj7A1LOdmdqWk31R0FvTfdi6/hsZpVM47J835bUlvdvdH3H3Q3V9x979RdKnFsXjcpzgBOxZIQz+3mNnpkn5d0tnTDNkg6QYzWzGX1wdSlqnfQ2l6pKNUsTybszGXT8A4kOA8lSd5rHceoJpG5XxaZvYRRX89kaK/nnA5Ziy0huQ83mPp7xT9dfs2d3+qnucD85TG5xZJ+rC7TznxtLs/oOiM/1J0PoXpfmkE6tGwzy1mdoWiPcDKR0gAAA0oSURBVPbeImmXpF+TdFw870pFn1f6Jb1T0sNmdma9cwApy9TvoTQ90nG4Ynk2u/CU//Ixm13t5jpP5V9X6p0HqKZROa/KzN4n6ZPxwx5Jb3L3vhpPAeaiUTn/qKTTFB33+vE6nwvMVxqfW15x9401xv57xfKFdc4DVNOQnMdN7LskLZW0W9Il7n6nu7/s7sPu/oK7f0HSlYp+cTxB0lfqmQPIgEz9HtqSxIuiNncvmdleSUdr4klepohPWlcOws5aY6uoPGlMzXk08aQx9c4DTNHAnFd7vXcpuqSnJO1QdEzsqzWeAsxJA3NePmHjdyS9ZZq9+cuv3Rlf4UWS9rj7d+ucC5iggTmvHF/Pie+OqXMeYIoG5vwXJJUPWfm8u++epp5nzOxORXusnm9m57r7k3XOBaRl8u+hj9YYm/jvoTQ90rNZ0hWS1phZS43LYq2tWK73ihObp3mdhZ4HmE4jcj6Bmf2iojOiN0l6SdK17j7Th2dgPhqR8/Kuob8R32pZpuiviJJ0nySaHlgIjcj5MxXLzdOOmrq+1qVFgXo0IueVl7h9fIaxj2n8MN21ik56CiwGc/k9dETSs0kUw+Et6Xkgvu+UdH6NcVdVLD9Y5xzPS3qxyutUc2V8v0vS9jrnAabTiJy/xsyulfSPihq6exXt4fHcXF8PmKWG5hxISeI5d/cdkn4aP1w1wwlKX1+xvKueeYAaGrE9r2ykzPQH6NZpngdk3SMaP4HptL+HmlmbpEvKz3H34SSKoemRnn+uWK76Vzsza1J0VmdJOqDo0lWzFp/Z/5744Vozu6TauPjr5Q7bPVwRAAso8ZxXvM6livLeruhyhj/v7s/UfhawIBqxPbeZbooO5ZKkHRVfv7rO7wWYTqO25/8jvl8i6doa495esfzAtKOA+jQi589XLF8xw9jKXxafn3YUkDHufljSf8QPf9bMpjtk7O2KtveSdHdS9dD0SIm7Pyzp/vjhDWa2ocqwD2p8F7jbJne+zOxqM/P4dsc0U31OUvnM5583swmXAYoffz5+OBKPBxZEo3JuZuskfUvRX2b6JF3n7o8txPcAzKSB23MgNQ3+3FI+6/9fmNmSyQPM7FclXR0//Ja7cy4yLIgG5fw/FF2ZRZLeb2ZVrz5kZm+U9Lb44S5JT8z+OwGSZWbvqcj5zdMM+/P4vkXSX5nZhMMWzWyZpD+LHx6Q9MVEihXn9EjbTYp2ieuQdK+ZfVJRt7hD0SWq3huP2yLp1rlM4O5bzOwzkv5Q0gWSHjSzP5P0nKJdQz8s6bx4+GfcPZHjqBC0RHNuZq9XdBb/I+Iv/ZGkg2Z2Vo2n7XH3PfXOBdSQ+PYcyIBGfG75qZn9V0mfVnQp2ofjzy1PKfpr4NslvT8efkjS78/tWwGmlWjO3f2Amf2ppE9I6pb0AzP7vKRvS9ov6VhJ10v6LY3/gfoP3X1szt8RUMHMLpe0puJLyyqW15jZeyrHu/sdc5nH3b9rZl9X9O/mFyV928w+p+j0C2crujLdifHwD7v7/rnMMxs0PVLk7hvN7B2S7lT0H/knqwzbouiv1oerrJutj0paLuk3FTU4vl5lzN8r+mURWFANyPkVivJd9tlZPOcWSTfPYS6gqgZuz4HUNCrn7v4ZMztK0R9mTpP0pSrD9kh6K3+swUJrUM7/WNJRihosXZI+Et8mG5b0/7r7nXOcB6jmRknvnmbdZfGt0h3zmOs3Ff07epOka+JbpTFJ/83d/24ec8yIw1tS5u7flHSOol/Utija3e2Aosv6fFjSee6+dZ5zjLn7DZKuU3TOgxcVnVjmxfjxm9z9RjrISEojcg6kjZwjBI3Kubt/RNEH768pOsH6oKLzNT0i6WOSTnX3h+Y7D1BN0jn3yO9LulDS30h6WtJhRYekH1R01Za/kHSWu//5tC8EZJy7D7j7dZJ+RdHeTHsU/R66U9L/J+lyd7856TqMc1YCAAAAAIA8Yk8PAAAAAACQSzQ9AAAAAABALtH0AAAAAAAAuUTTAwAAAAAA5BJNDwAAAAAAkEs0PQAAAAAAQC7R9AAAAAAAALlE0wMAAAAAAOQSTQ8AAAAAAJBLND0AAAD+//buPlTPuo7j+Pszp1Jb2koz2dhGM1uLlj2tQpNlWkFYoD2MRmWZQoFo1CxHtFHErKyFPZBEURbJwDSF+sOedKWtUIRcptNM04SEpSk1tdy3P6770L1r1/HsjnPfB6/eL7jgvn4P3+t3/jvnc37X75YkSb1k6CFJkiRJknrJ0EOSJEmSJPWSoYckSZIkSeolQw9JkiRJktRLhh6SJEmSJKmXDD0kSZIkSVIvGXpIkiRJkqReMvSQJEmaoCTLk1TrurZj3OaOcWdMfsWSJD11GXpIkqRZMc0f6cPX3iSPJLknyTVJNiZZNtfrliRJ/WXoIUmSJiXAQmApcArwGeD2JBvmdFWSJKm3DD0kSdJcOhT4XJL3zPVCJElS/8yf6wVIkqRe+wtw+eDzIuAVwKqOcZuASye1KEmS9P/B0EOSJI3TnVV13tRNkgBfBT7YGve8JMuq6p6Jrk6SJPWaoYckSZqYqqokF7F/6AFwNNAZeiRZCJwBvAE4Dnj2oOsBYAewDbiqqmqmNSR5BvBumnNFjgOOAA4G/grcC1wH/KiqbmjNWwGcSLNb5TjgSOBZwOHAo8DfgFuAnwLfrardM61FkiSNl6GHJEmatPunaX+oqzHJOuBrNK/HtC0fXOuAHUneXlX3TffgJO8DttIEFW1LB9fxwPpB3WGfBU6fpvRC/ntI65uBTUk+UFU/mG4tkiRp/DzIVJIkTdqSjrZ/AXe3G5OcB1xGd+DR9mqa4OPors4knwa+RXfgMdueCVyW5DUTeJYkSZqGOz0kSdLEJJkHnN/R9b2qerQ1dg3whY6xO4EbaV5JWQssHupbTHMg6imtWqcCn+io9QRwLXAHcAjwEuBlM/wYdwN3ArsHV2hezTme5pWXKQfTfC3vSTPUkyRJY2LoIUmSxumYJF8afF4EvBJ4YWvMXcAnO+ZuZv9dqedU1VembpI8DbgSeOPQmJOTnFhV24fatnTU3wW8papuH25M8nzg7I7xFwMfq6o/dvSRZAHwE2B4d8faJIuq6sGuOZIkabwMPSRJ0jgtBs6dpm8vcAVwblXtc85HksNo7dYAfjsceABU1Z4kn2Lf0APgbcD2Qa2VwIs6nn1aO/AY1LwD2NDRPlVvIc2ujpU0B6ouAA4aDDuoNS00h57+ol1PkiSNn6GHJEmaKzuBi9uBx8DL2f/3lDVJZvx2loHh3Rav6uj/VVX9/gBrAZDkOTQ7RtYDh44w9YhRniNJkmaPB5lKkqS5shr4eZJ3dvQd2dE2iucOfT6qo/+2UYolWQRcD7yf0QIPgKePOF6SJM0SQw9JkjRO11VVaP7wPwH4dat/PvDNJMfM8nMXznK9jcD/usbM5kIkSdKB8/UWSZI0dlW1B7g+yZuA3wHLhroXABfSnMMx5YGOMrfSHBR6IPbMUGvlAdaZ8taOtm/TfLvMXVX1T4AkW4CPj1hbkiSNiaGHJEmamKp6OMkFwPdbXacneWlV3Ty4v5nm62SHDwadD3y4qmY81yPJ8LzfdAw5Icmqqrr1AJe+tHX/MHBmVe1ttXedHyJJkuaIr7dIkqRJ2wbc2dG+cepDVf0d+Fmr/1jgksFXw+4nyZIkH0pyE/DaoVp/ANqHls4Drkzygo46y5Jc2Gp+vHW/EFgxNCdJPgK8rmttkiRpbrjTQ5IkTVRV7U3yeeCSVtdpSVZW1dQho5uAk9n3nzRnAe9Ish24f9B3FM1X0q5gehuBq1ptxwI7k1wH7AIOAVYBa4D72Pc1lZuAtUP384Abk/wY+Mdgzouf5PmSJGkOGHpIkqS58B1gM3D0UNs84ALgvQBVtSPJR4EvtuYeDpw6ysOq6urBeRsXtLrmA68fXE/my+wbegAcBqwbuv83sB04aZS1SZKk8fH1FkmSNHFV9RiwtaPrXUmWD43bShMs7B6h/C00u0Daz9wInA08MspaB3OvAC56kiGPA2cCvxy1tiRJGh9DD0mSNFe+DjzUapsPnD/cUFXbaA4SPQu4HPgTTXDxBM2BorcBPwQ2AKuranVV7ep6YFV9A1gCnANcDfyZ5vWUx4B7gRuALcD6jrkbaHaYXAM8OJhzD82ulTVVdelIP70kSRq7HMAB6JIkSZIkSU857vSQJEmSJEm9ZOghSZIkSZJ6ydBDkiRJkiT1kqGHJEmSJEnqJUMPSZIkSZLUS4YekiRJkiSplww9JEmSJElSLxl6SJIkSZKkXjL0kCRJkiRJvWToIUmSJEmSesnQQ5IkSZIk9ZKhhyRJkiRJ6iVDD0mSJEmS1EuGHpIkSZIkqZcMPSRJkiRJUi8ZekiSJEmSpF4y9JAkSZIkSb1k6CFJkiRJknrJ0EOSJEmSJPWSoYckSZIkSeolQw9JkiRJktRLhh6SJEmSJKmXDD0kSZIkSVIvGXpIkiRJkqRe+g/eMvERFGeYDwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1200x740 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "ps, rs, ths = ([], [], [])\n",
    "th = np.max(pred_es)\n",
    "while th >= 0.0:\n",
    "    p, r = pr_at_th(th)\n",
    "    if p > 0:\n",
    "        ps.append(p)\n",
    "        rs.append(r)\n",
    "    else:\n",
    "        ps.append(1.0)\n",
    "        rs.append(0.0)\n",
    "    ths.append(th)\n",
    "    th -= 0.0005\n",
    "    \n",
    "from sklearn import metrics\n",
    "\n",
    "print(f'AUC: {metrics.auc(rs, ps)}, max R: {max(rs)}, max P: {max(ps)}')\n",
    "    \n",
    "i = len(rs) - 1\n",
    "while rs[i] == 1.0:\n",
    "    i -= 1\n",
    "i += 1\n",
    "print(f'100% recall at: {int(ps[i] * 100)}%, threshold: {ths[i]}')\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(6, 3.7), dpi=200)\n",
    "\n",
    "ax.spines['top'].set_color('#808080')\n",
    "ax.spines['right'].set_color('#808080')\n",
    "ax.spines['left'].set_color('#808080')\n",
    "ax.spines['bottom'].set_color('#808080')\n",
    "ax.tick_params(direction='in', color='#808080')\n",
    "\n",
    "plt.grid(color='#c0c0c0', linestyle='--', linewidth=0.5)\n",
    "\n",
    "plt.ylabel('Precision', fontweight='bold')\n",
    "plt.xlabel('Recall', fontweight='bold')\n",
    "\n",
    "plt.xlim((0.0, 1.0))\n",
    "plt.ylim((0.0, 1.0))\n",
    "\n",
    "_ = plt.plot(rs, ps)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
